Finality
This page describes when a transaction becomes final in a LinethLineth (Formerly the Linea Stack) The open-source ZK-rollup stack, codebase, and technical protocol that's the foundation of Linea Mainnet. Operators can deploy this stack to launch their own Ethereum-compatible L2 or L3 networks. deployment: at block production on the network (application-level finality), and when the matching state is verified on the finalization layerFinalization layer The blockchain where a Lineth deployment submits proofs and state commitments for verification and hard finality. If the finalization layer is Ethereum (an L1), the deployment is an L2. If the finalization layer is Linea (an L2), the deployment is an L3. (settlement finality).
How fast finality is, and what makes it irreversible, depends on validatorMaru validator A Maru consensus client that belongs to the QBFT validator set and proposes and votes on blocks. Each Maru validator requires its own dedicated Linea Besu execution client running the sequencer plugins, which builds the payload Maru then signs and broadcasts. A validator can also drive additional follower execution clients. topology, proof generation and submission, and the chosen finalization layer.
Application-level and settlement finality
Finality is the point at which a transaction is immutable under the deployment's security assumptions.
- Application-level finality (or soft finality) is reached when the Lineth network has accepted the transaction as final. This happens when the configured validator model commits the block.
- Settlement finality (or hard finality) is reached when the matching state commitment has been verified and recorded on the finalization layer.
Every Lineth deployment produces blocks on the network and submits zk-SNARKzk-SNARK (Zero-Knowledge Succinct Non-interactive Argument of Knowledge) A type of ZK proof where the prover and verifier don't have to interact. With zk-SNARKs, you can verify 1 transaction or 1 billion transactions in the same amount of time. proofs to a finalization layer. Application-level finality is what apps see at block production. Settlement finality is what the finalization layer attests after proof verification.
Application-level finality design
Application-level finality depends on the configured validator model.
| Validator model | When application-level finality is reached | Trust assumption |
|---|---|---|
| Single Maru validator | When that validator produces and commits the block | The operator's sequencer is trusted. No consensus-driven forks or reorgs are expected by design |
| Multiple Maru validators (QBFT) | When a supermajority (≥2/3) of authorized validators commit the block, typically within seconds | Byzantine fault tolerance of the validator set (n=3f+1) |
A single-validator deployment prioritizes simplicity and low latency. Use it when validator trust is explicit and a single sequencer is acceptable. For example, Linea Mainnet uses a single validator.
A multi-validator deployment finalizes each block when the authorized validators commit it. Use it when more than one party must participate in block ordering, or when the chain should keep producing blocks if one validator fails. For topology, latency, and setup, see Multi-validator consensus.
Block time is an operator parameter on the Maru validator. Choose block time and topology together so each block can be produced and committed in time. A single validator produces the block alone, so block time must leave room for that validator's availability. For example, Linea Mainnet uses 1-second blocks. A multi-validator set must finish the QBFT commit within the block time; choose a block time based on network latency and validator performance.
Settlement finality design
Settlement finality is reached when the coordinatorCoordinator Lineth's coordination module for batching, proof generation, and finality submission. The coordinator monitors block production, manages conflation deadlines, batches blocks, combines batches into blobs, orchestrates execution, compression, and aggregation proofs, and submits proofs and data to the finalization layer. has submitted the proof, the finalization layer has verified it, and that layer has itself finalized the verification transaction.
The finalization layer choice changes settlement time and cost:
- Ethereum (L1): direct settlement on Ethereum; higher cost and longer finality.
- Linea Mainnet (L2): faster, cheaper settlement on Linea; the deployment also inherits Linea Mainnet's path to Ethereum.
Data availability does not change when settlement occurs. It changes who can reconstruct history if they need the settled state.
See also
- Linea transaction finality: Soft and hard finality on Linea Mainnet.
- Multi-validator consensus: How QBFT changes application-level finality and sequencer fault tolerance.