Skip to main content

Coordinator

The coordinator is the 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. orchestration service. It drives everything between block production and finalization: it groups blocks into provable units, requests each proof from the proverProver The Lineth component that generates ZK proofs of state transitions, handling proof-generation requests from the coordinator and Linea Besu. The prover produces three types of proofs (execution, compression, and aggregation) and combines them into a zk-SNARK that the finalization layer verifies. Provers may be scaled horizontally to meet throughput requirements., and submits the proofs and the transaction data to 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..

The coordinator is also the channel between the network and its finalization layer in both directions. It sends the network's data and proofs to the finalization layer. It also reads finalized state from that layer and passes it to the components that need it.

How it works​

The coordinator runs a set of services that share a database, each picking up work as the previous stage makes it available:

  1. It conflates blocks into batches, using trace counts from the tracerTracer The Linea Besu plugin, part of the sequencer, that generates the execution traces the prover needs to create zero-knowledge proofs. The tracer provides trace counts for batch-size calculations and produces conflated trace files as prover input., and requests an execution proof for each batch it closes.
  2. It compresses conflated batch data into blobs, and requests a compression proof for each blob.
  3. It groups consecutive proven blobs and requests an aggregation proof, a single proof that stands in for the whole group.
  4. It submits blobs to the rollup contract on the finalization layer, then submits the aggregation proof to finalize that range of blocks.
  5. It polls the finalization layer for newly finalized state, feeds that back into conflation, and notifies the state managerState manager The Lineth component that maintains the network's state representation for proof generation and recovery. It consists of a Besu node with the Shomei plugin and a Shomei node that uses sparse Merkle trees to track state changes block by block, generate Merkle proofs for state transitions, and serve linea_getProof RPC requests..

Each stage records its results in the coordinator's database, so the stages can advance at their own pace and resume from the last persisted state after a restart.

The coordinator handles two jobs outside the proving pipeline. It anchors incoming messages from the finalization layer on the network, so the canonical message service can deliver them, and it computes and propagates the gas pricing that the network's nodes advertise.

info

On Linea Mainnet, the coordinator currently submits finalizations to Ethereum approximately every two hours.

See also​

Was this page helpful?