(LEE-nee)

Watch rollup blocks settle on Ethereum.

Rollups sign a block every second or faster and post it to Ethereum in a blob within minutes. From then on it is as final as the Ethereum block that carries it: confirmed in about 13 seconds, final in about 15 minutes, settled for withdrawals in days. Every block below is one leani saw.

Ethereum
MainnetHoodi and Sepolia testnets
OP Stack
Base, Ink, Mode, OP Mainnet, Soneium, Unichain, World Chain, ZoraBase Sepolia testnet
Arbitrum Nitro
Arbitrum Nova, Arbitrum One, Robinhood Chain
a rollup block, faint until signeda batch, threaded to its Ethereum blockan Ethereum block and its blobs:seenattestedconfirmed, fast confirmation rulefinalizedreorg

# Right now

Medians over the blocks above, from when each block was made. ~ marks Ethereum’s own times, until a batch seen live gets there.

chainblock timeseen aftersigned afterin a blob afterconfirmed afterfinal aftersettled
OP Mainnet———————
Base———————
Ethereum———————
Arbitrum One———————
Robinhood Chain———————

# What each stage means

Solid cards are levels leani reports; dashed ones are milestones it does not.

  1. attested

    Sequencer-signed

    The chain’s sequencer signed the block in its gossip, checked against the key in leani’s chain entry. Blocks reach attested about as fast as unattested.

    typical~1 s

    undone by Only if the sequencer reorgs its own unsafe chain.

  2. milestone

    In a blob on Ethereum

    The batcher compresses a run of blocks into a channel and posts it as blobs to the chain’s batch inbox. Leani’s blobs processor sees the transaction in an Ethereum block; the page decodes which blocks the blobs carry. From here on, anyone can derive the blocks from Ethereum.

    typicalOP Mainnet minutesBase ~30 s

    undone by An Ethereum reorg of the block that carries the blobs; the batcher then posts them again.

  3. finalized

    Final on Ethereum

    The Ethereum block that carries the blobs is finalized, so the blocks’ data can no longer change. Leani reads the batches from finalized Ethereum blocks, checks each blob against its versioned hash, and finalizes the blocks they carry, as op-stack nodes do.

    typical~15–30 min

    undone by Never.

  4. settled

    Settled on Ethereum

    A dispute game claimed the block’s output root, or on OP Mainnet a super root over it, and the anchor state registry moved to it after its challenge window, read from finalized Ethereum blocks and their receipts: withdrawals can complete.

    typicalOP Mainnet ~7 dBase ~5 d

    undone by Never.

# Consume the level you need

A processor publishes from one level up; its stream marks every later rise. Pick the first level your app may act on.

unattested

Fastest

UIs that show activity the moment it happens and can take a block back.

publish = "unattested"  # the default
leani subscribe blocks

attested

Signed

Apps that must never act on a block nobody vouched for: Ethereum’s sync committee, or the rollup’s sequencer.

publish = "attested"
leani subscribe blocks --finality attested

confirmed

Confirmed

Deposits and payouts on Ethereum that cannot wait a quarter of an hour: the fast confirmation rule, as the consensus nodes you name report it.

publish = "confirmed"
leani subscribe blocks --finality confirmed

finalized

Final

Accounting and anything that cannot be undone: Ethereum finality, or the rollup’s batch final on Ethereum.

publish = "finalized"
leani subscribe blocks --finality finalized

settled

Settled

Withdrawals and bridges that wait for Ethereum to accept the rollup’s state, days after its blocks.

publish = "settled"
leani subscribe blocks --finality settled

The CLI follows Ethereum Mainnet; on any chain’s node, the SDK reads the same levels from one stream:

import { createLeaniClient } from "@smart-byte/leani-sdk";

const leani = createLeaniClient({ baseUrl: "http://127.0.0.1:18080" });
for await (const change of leani.blocks.subscribe()) {
  switch (change.operation) {
    case "apply":     show(change.data, change.finality); break;
    case "attested":
    case "confirmed":
    case "finalized":
    case "settled":   promote(change.data, change.operation); break;
    case "undo":      remove(change.block); break;
  }
}

The Ethereum node runs the blobs processor, which names each blob transaction’s sender and the address it posts to: that is how the page knows whose blob it is. The hub fetches the blobs from a Beacon API and decodes the blocks inside.

// On an Ethereum node that runs the blobs processor
for await (const change of leani.blobs.subscribe()) {
  for (const blob of change.data?.transactions ?? []) {
    // OP Mainnet's batcher posts to 0xff…0010
    if (blob.toAddress === OP_BATCH_INBOX) posted(change.block, blob.blobVersionedHashes);
  }
}

# Two ways to rest on Ethereum

Data. Once the Ethereum block carrying a rollup block’s batch is final, anyone can derive the block from Ethereum and it can no longer change. That is leani’s finalized for a rollup, as op-node and Nitro call it: leani reads the batches from finalized Ethereum blocks. It takes minutes and shows as a dashed line in each rollup’s row.

Settlement. For withdrawals, Ethereum must also accept the rollup’s claim about its state, after a challenge window of days. That is leani’s settled, read from the settlement contracts’ logs in finalized Ethereum blocks, no RPC trusted. The picture’s right edge names how long each rollup takes, and opens onto those days once a node that holds them reports a settled block.

  • OP Mainnetsuper-root games, ~7 d
    Dispute games whose claim is a super root: one commitment to the output roots of several interoperating chains at the same moment. leani checks OP Mainnet’s own root inside it; otherwise the game works like any dispute game.
  • Basedispute games, ~5 d
    Op-stack fault proofs: a proposer claims the chain’s state at one block, its output root, in a game on Ethereum that anyone can challenge. Once the claim outlasts its challenge window, the anchor state registry moves to it and withdrawals up to that block can complete.
  • Arbitrum OneBoLD, ~6.4 d
    Arbitrum’s dispute protocol, Bounded Liquidity Delay. About every hour a validator posts an assertion naming the block hash at the end of a range, and the rollup confirms it after a 6.4-day challenge period. However many parties dispute an assertion, BoLD resolves it within a fixed time.
  • Robinhood ChainBoLD, ~6.4 d
    Arbitrum’s dispute protocol, Bounded Liquidity Delay. About every hour a validator posts an assertion naming the block hash at the end of a range, and the rollup confirms it after a 6.4-day challenge period. However many parties dispute an assertion, BoLD resolves it within a fixed time.

# Run it yourself

The example starts one node per chain, Ethereum’s with the blobs processor. Its hub follows them with the SDK, decodes the batches, reads fast confirmations from a beacon node, and streams this page. Op-stack nodes need a public address for their gossip.

cd leani/examples/finality-live
./nodes.sh init ./nodes
./nodes.sh start ./nodes
bun hub.ts $(./nodes.sh hub ./nodes) \
  --beacon https://ethereum-beacon-api.publicnode.com \
  --fcr https://lodestar-mainnet.chainsafe.io --port 8797
open "https://leani.dev/finality?hub=http://127.0.0.1:8797"