unattested
Fastest
UIs that show activity the moment it happens and can take a block back.
publish = "unattested" # the defaultleani subscribe blocksRollups 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.
Medians over the blocks above, from when each block was made. ~ marks Ethereum’s own times, until a batch seen live gets there.
| chain | block time | seen after | signed after | in a blob after | confirmed after | final after | settled |
|---|---|---|---|---|---|---|---|
| OP Mainnet | — | — | — | — | — | — | — |
| Base | — | — | — | — | — | — | — |
| Ethereum | — | — | — | — | — | — | — |
| Arbitrum One | — | — | — | — | — | — | — |
| Robinhood Chain | — | — | — | — | — | — | — |
Solid cards are levels leani reports; dashed ones are milestones it does not.
attested
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.
milestone
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.
finalized
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.
settled
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.
unattested
At least two execution peers served the same header, it passes leani’s header rules (base fee, gas limit, blob gas, slot timing, fork fields), and it extends the delivered chain.
typical~2–5 s
undone by A reorg, an attested head on another block, or 60 s without an attestation.
attested
At least 342 of the 512 sync-committee members signed it or a descendant, verified locally from a light-client update.
typical~15 s
undone by A reorg.
confirmed
The fast confirmation rule: enough of the slot’s attestations back the block that no reorg removes it while the network is synchronous. Leani takes it from the consensus nodes you name and counts it only for blocks it verified as attested, so its confirmed level lands with attested. The page reads the rule’s own stream, a moment earlier.
typical~13 s
undone by Only a reorg during a long network partition.
finalized
Casper FFG finality, verified locally from a light-client finality update.
typical~13–19 min
undone by Never.
attested
The sequencer feed message carries the block’s hash signed by the batch poster. Endpoints only carry blocks: one with another hash is refused.
typical<1 s
undone by Only if the sequencer reorgs its own chain.
milestone
The batch poster posts the sequenced transactions to Ethereum, calling the chain’s SequencerInbox with its message counts before and after the batch: the page reads which blocks the batch carries from that call.
typicalminutes
undone by An Ethereum reorg before the batch’s L1 block is final.
finalized
The Ethereum block with the batch is finalized. Leani reads the SequencerInbox call in it, whose message count names the batch’s last block, and finalizes the blocks up to there, as Nitro nodes do.
typical~15–30 min
undone by Never.
settled
A validator posts a BoLD assertion naming the block hash at the end of its range, about every hour, and the rollup confirms it after the challenge period, read from finalized Ethereum blocks and their receipts.
typical~6.4 d
undone by Never; before confirmation, a successful challenge replaces the assertion.
A processor publishes from one level up; its stream marks every later rise. Pick the first level your app may act on.
unattested
UIs that show activity the moment it happens and can take a block back.
publish = "unattested" # the defaultleani subscribe blocksattested
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 attestedconfirmed
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 confirmedfinalized
Accounting and anything that cannot be undone: Ethereum finality, or the rollup’s batch final on Ethereum.
publish = "finalized"leani subscribe blocks --finality finalizedsettled
Withdrawals and bridges that wait for Ethereum to accept the rollup’s state, days after its blocks.
publish = "settled"leani subscribe blocks --finality settledThe 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);
}
}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.
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"