Skip to main content

Fast finality

Linea transactions progress from submission to soft, and then to hard finality.

Transaction finality​

Public Linea Mainnet transactions are finalized on Ethereum, making Ethereum the layer 1 (L1) and Linea the layer 2 (L2).

Finality switches between three states, pending, soft, and hard:

  • Pending: A transaction is submitted and various compatibility and logic checks are underway.
  • Soft finality: The transaction is confirmed on Linea. This takes two seconds (Linea's block time).

    For simplicity, Linea is guaranteed to not reorg—remove competing versions of blockchain history in favor of a canonical one—the L1, however, may reorg.

  • Hard finality: The proof submitted to L1 has been verified and two epochs have elapsed.
info

In December 2025, Linea reached a median hard finality time of less than 1 hour and 40 mintues. This median time will continue to decrease, and is expected to reach ~30 minutes in the near future. Occasionally, high gas costs and upgrades can cause delays in finalization, but hard finality timing should never exceed 16 hours.

The following sequence diagram matches the 6 steps described below to detail the finality state of a transaction.

info

For custom deployments, Linea network operators may select an alternative finalization layer, and select validator logic thereby determining how and where transactions reach hard finality.

To reach hard finality, a transactions must complete the following steps:

Step 1: Submission​

Finality: None (pending)

A user signs a transaction and broadcasts it to Linea. These transactions enter the mempool as pending.

Step 2: Block building​

Finality: None (executing)

The Linea sequencer is responsible for ordering, building, and executing blocks.

The sequencer checks the validity of each transaction added to the mempool, rejecting transactions as necessary.

The sequencer orders transactions, taking into account the priority fee paid. Valid transactions are placed into blocks in the correct sequence and executed.

Validity

While the Linea chain may be followed using any Ethereum-compatible client, transaction validity conditions are specific to Linea, and differ slightly from those of other networks, including Ethereum.

At this point, the execution layer's state changes and the block containing the transaction is added to the "head" of the Linea blockchain—the most recent block—and a transaction receipt is returned to the user's wallet as confirmation.

  • Components: Besu with sequencer plugins

Step 3: State tracking​

Finality: Soft finality (Linea)

Data about the transaction and the state of the network at its time of execution are recorded in traces, an output of part of the sequencer called the trace generator.

Traces are passed to the state manager block-by-block and then used to record and track state changes for batching and proof generation. With the transaction executed and state updated, the transaction has reached soft finality and the user sees the transaction reflected and confirmed in their wallet.

From Linea's perspective, the transaction is complete, however, an L2 like Linea must still reach hard finality on the finality layer.

  • Components: Besu with tracer plugins

Step 4: Conflation​

Finality: Soft finality (Linea)

The transaction's block undergoes conflation: multiple consecutive blocks are merged into a single batch that forms part of the package of data posted to Ethereum.

Combining transaction data lets the system generate one proof for many transactions, reducing the cost of submitting proofs to the finalization layer.

Occasionally, a batch may only consist of one block, with no conflation having taken place. This occurs when chain activity levels are particularly high, and the block size is larger than normal.

Step 5: Blob and proof generation​

Finality: Soft finality (Linea)

This prover uses the transaction data, when prompted by the coordinator, Linea's prover expands the trace, preparing it for inclusion in the proof.

The prover generates proofs that the original and conflated—compressed—versions are computationally equivalent; after collecting several such proofs, the prover then compresses the proofs themselves, reducing the proof size by generating a single succinct proof which can be posted to the Layer 1.

This final zk-SNARK attests to the conflated batch (multiple blocks), enabling a single proof to verify many transactions. The coordinator combines batches into blobs for data availability.

Proving

Linea's prover employs a two-stage method for developing the proofs, providing an inner and outer proof. The inner proof uses a combination of tools, including Arcane and Vortex, to recursively reduce the proof size. The outer proof is generated using the Consensys-maintained library gnark, compressing the proof size even further. The resulting proof is the zk-SNARK: the proof that's submitted to Ethereum.

Step 6: Batch finalization​

Finality: Hard finality (Ethereum)

The proof for the batch is submitted to Ethereum Mainnet. This proof attests to the execution of all transactions in the batch, including our user's transaction introduced in step 1.

Two elements are submitted to the L1:

  • Blob data: which contains L2 transaction and messaging data
  • The proof: as detailed in step 5

The blob data shared with the L1 can be used to reconstruct Linea's state and verify the data underlying the proof—before it disappears from the L1, after 4,096 epochs (~18 days). The Linea rollup contract on L1 calls the Ethereum verifier contract which uses the blob data to determine whether or not to accept the batch as valid.

You can view finalized batches on LineaScan.

Once the proof is verified by the L1 and two epochs have passed, the transaction becomes immutable history, and reaches hard finality. Its lifecycle is complete.

  • Components: Coordinator, Ethereum finalization contract

Hard finality when?​

The time to hard finality depends on:

  • The proof generation time and other elements unrelated to network stress but linked to the prover configuration.
  • The network conditions of the finality layer, which determine the inclusion time of the committed L2 state.
  • The the time it takes for a block to be finalized once it has been included. For example, Ethereum requires 64 slots, approximately 13 minutes, to finalize.

Next steps​