Fastest L1 blockchain finality, live wall-clock measurement per chain
Wall-clock time for a block to become final on 18 chains, from Ethereum, Bitcoin and Solana to NEAR, Sei and Algorand, each against its own finality rule, measured live.
TL;DR. As of , SUI posts the lowest finality time at 0.25 s (p50, 24h) across 18 ranked chains. Source: OpenChainBench, https://openchainbench.com/benchmarks/l1-finality.
This page measures L1 finality time live on 18 chains, each against its own finality rule, with p50 / p90 / p99 over 24 hours. Solana finality time dropped from about 12.8 s under Tower BFT to 0.39 s when Alpenglow went live on 21 October 2026. Ethereum finality time is about 12.8 minutes in the ideal case, the 2-epoch Casper FFG window; measured wall-clock finality runs longer, 15.8 min. Single-slot BFT chains finalize a block the moment they commit it: Sei at 0.28 s, Cronos at 0.58 s, Kaia at 0.50 s, timed from the block's own timestamp to its arrival. NEAR reaches BFT finality in 1.2 s, the Internet Computer serves certified state 0.95 s after a block is made, and an Algorand round, proposal to certification, takes 2.8 s. Stellar closes a ledger every 5.0 s and Gram (formerly TON) commits a masterchain block every 0.40 s. Probabilistic chains (Bitcoin, Litecoin, Monero) settle on a confirmation-depth convention measured in minutes. Bitcoin takes 47.5 min to the industry-standard 6 confirmations; the protocol itself never reaches absolute finality.
Methodology
We measure how long a block takes to become final on every chain we can observe honestly from public endpoints, each against the chain's own finality rule. Four methods, picked per chain. Where a head and a final block coexist, T1 is when block N is first seen and T2 when it is final, lag = T2 − T1: over a persistent WebSocket for BNB, Robinhood Chain and Solana (millisecond precision, independent of block timestamp resolution), on block timestamps polled every 10 s for Ethereum, TRON and Monero, on NEAR's nanosecond header timestamps, and on our own clock at the tip for Bitcoin (6 confirmations) and Litecoin (12). Where every block is already final when it appears (Avalanche, Sei, Cronos, Kaia, the Internet Computer), latest to finalized is zero by construction, so the figure is the block's own timestamp to its arrival here. Stellar, Gram, SUI and Algorand report the interval between two final ledgers, masterchain blocks, checkpoints or rounds. Robinhood Chain is the one rollup on the board (Arbitrum Orbit): its `finalized` block only moves when a posted batch is finalized on the parent chain, thousands of blocks at a time, so its row reports the median lag of each batch. Hedera, XRP, Aptos and Somnia are not measured; the methodology says why.
- Cadence: every 10 seconds for Ethereum, TRON and Monero; continuous WebSocket or SSE streams for BNB, Avalanche, Robinhood Chain, Solana, Sei, Cronos, Kaia, Stellar and Gram; a long poll for Algorand; 250 and 500 ms polls for the Internet Computer and SUI; 2 s for NEAR, whose figure comes from block timestamps; 30 s for Bitcoin and Litecoin.
- Ethereum: `eth_getBlockByNumber("latest")` minus `eth_getBlockByNumber("finalized")`.
- Avalanche (WS, from production): since Streaming Asynchronous Execution went live on 2026-09-22, `latest` is an accepted (Snowman-final) and executed block and `finalized` is the settled block, 5 s later by design. The figure is therefore arrival over `newHeads` minus the header's `timestampMilliseconds` (proposer clock); readings outside 0 to 60 s are dropped as skew. From 2026-09-22 to 2026-10-24 the row timed latest to finalized and published the settlement delay, about 6 s.
- BNB (WS wall-clock): persistent `eth_subscribe("newHeads")` records T1 = first time block N is seen as latest. Periodic `eth_getBlockByNumber("finalized")` over same WS records T2 when N becomes finalized. lag = T2 − T1, ms precision. Since 2026-11-03 a socket with no head for 20 s or no finalized advance for 30 s is reconnected: before that, the public node could stop sending heads for hours while still answering, and the row held its last value.
- Robinhood Chain (rollup, WS wall-clock): same subscription as BNB / Avalanche on `wss://robinhood-rpc.publicnode.com`. `finalized` advances by whole batches once they are finalized on the parent chain (about 10,000 blocks at about 100 ms each), so every block of a batch is timed, all of them enter the histogram, and the published series carries the batch median: the last block of a batch always has the smallest lag and would understate finality.
- Solana: WebSocket `slotSubscribe` and `rootSubscribe` on the public mainnet endpoint. T1 = first notification of slot S, T2 = first root at or above S; lag = T2 - T1 in ms. Replaced the `getBlockTime` difference on 2026-10-22, after Alpenglow made finality shorter than its one-second resolution.
- TRON: `/wallet/getnowblock` (head) minus `/walletsolidity/getnowblock` (solidity-confirmed).
- Stellar (ledger close times): Horizon `/ledgers?cursor=now&order=asc` event stream, SCP-final at every close; sample = (closed_at(N) - closed_at(N-10)) / 10, once per new ledger. Before 2026-11-03 the sample was the gap between two ledgers arriving on the stream, which measured Horizon's uneven delivery: median 4.0 s on a chain closing every 5.0 s.
- SUI: latest checkpoint from the official GraphQL service (`graphql.mainnet.sui.io`), polled every 500 ms; sample = (timestamp N − timestamp M) / (N − M) over the checkpoints committed between two polls, from the checkpoints' own millisecond commit timestamps. Before 2026-10-24 the sample was the gap between two polls that saw a new checkpoint, which only measured our 500 ms poll; that day it also moved off `sui_getLatestCheckpointSequenceNumber`, retired with JSON-RPC on the public fullnodes.
- Gram: wall-clock interval between consecutive masterchain seqnos on the tonapi.io block stream (`workchain=-1`), first sight of N+1 minus first sight of N; a transaction is final once a masterchain block includes it. When the stream is unavailable a 300 ms REST poll of the masterchain head stands in, with intervals over 2 s dropped as poll aliasing.
- Bitcoin (probabilistic, own-clock): mempool.space `/blocks/tip/height` polled every 30 s. T1 = first poll where block N is the tip, T2 = first poll where tip − N ≥ 6 (the exchange deposit convention). lag = T2 − T1 on the harness clock; miner-set block timestamps (consensus allows 2h skew) are never used. The startup tip is not timed. On a tip regression, pending timers above the new tip are dropped; same-height reorgs are invisible to height polling, bounding error to about one block interval.
- Litecoin (probabilistic, own-clock): Tatum public JSON-RPC `getblockcount` polled every 30 s. T1 = first poll where block N is the tip, T2 = first poll where tip − N ≥ 12 (the post-April-2026 MWEB reorg deposit floor). Same rules as Bitcoin: the startup tip is not timed, skipped heights are never timed. Until 2026-10-24 this row was the timestamp gap between the tip and the block 12 below it on litecoinspace.org, whose index had fallen about 30 minutes behind the chain.
- Monero (probabilistic): monero-rpc `get_info` minus 10 confirmations via `get_block_header_by_height`.
- NEAR (chain timestamps): every 2 s, the optimistic head from dRPC's free NEAR endpoint, plus its parent and its `last_final_block` F by hash. Sample = timestamp of the head minus timestamp of F, both nanoseconds, kept only when the parent named an older final block, so the head is the first block naming F.
- Sei and Cronos (CometBFT, from header time): `NewBlockHeader` subscription on the publicnode Tendermint WebSocket; sample = arrival minus header `time` (ns). A block is final when committed. On Sei the header time is this block's proposal; on Cronos it is BFT time, the previous height's commit, so the Cronos figure covers one whole height.
- Kaia (from block start): `newHeads` on the public Kaia endpoint WebSocket. The producer starts a block at its parent's timestamp plus one whole second (kaia work/worker.go), so for a block whose timestamp is its parent's plus one, sample = arrival minus that second. Late blocks, timestamped with a fraction newHeads does not carry, are skipped.
- Internet Computer (certified state): anonymous `read_state` for `/time` on the NNS subnet through icp-api.io, every 250 ms. When the certified time advances, sample = arrival (midpoint of the two answers' receive times) minus that time, the batch time of the block that produced the state.
- Algorand (round time): algod `wait-for-block-after` long poll on the Nodely (algonode) free endpoint; sample = arrival of round r+1 minus arrival of round r, consecutive rounds only. Block `ts` is whole seconds, so it is not used.
- Hedera (planned, currently disabled): mirror-node `/api/v1/blocks` only exposes already-final blocks, so true wall-clock lag is impossible from public endpoints. Re-enables once Block Nodes (HIP-1056) leave private preview.
- Result for the 10 s polled chains (Ethereum, TRON, Monero): `lag_seconds = headTimestamp - finalizedTimestamp`, with the block-height delta and per-chain fetch latency. Every other chain publishes milliseconds to `l1_finality_wallclock_lag_milliseconds`.
- Excluded by design: XRP (no close-time on `ledger_current`, wall-clock measurement requires WS subscribe to ledger stream, not yet implemented).
- Excluded, Somnia (checked 2026-11-03): `latest`, `safe` and `finalized` are the same block and block timestamps are whole seconds on blocks about 100 ms apart, so neither a head to finalized gap nor a timestamp to arrival time can resolve its sub-second finality.
- Excluded, Aptos (checked 2026-11-03): a fullnode serves only committed blocks, and the latest block's microsecond timestamp read 0 to 200 ms before arrival, often after our request left, so it does not mark the proposal. The Aptos Labs API also answered 429 at four requests a second.
- Failures (5xx, timeouts, rate limits) leave the previous gauge in place and increment a per-chain `fetch_errors_total` counter; the page falls back to the last successful sample.
Results: 18 chains ranked by Finality time (p50, 24h)
| № | Chains | p50 | p90 | p99 | Success |
|---|---|---|---|---|---|
| 1 | SUIMysticeti DAG, measured via wall-clock checkpoint cadence | 0.25 s | 0.26 s | 0.28 s | 100.00% (n=170138) |
| 2 | SeiSingle-slot BFT, header time to arrival | 0.28 s | 0.34 s | 0.40 s | 99.51% (n=180721) |
| 3 | SolanaAlpenglow, measured via WS wall-clock | 0.39 s | 0.60 s | 0.87 s | 98.78% (n=396262) |
| 4 | GramMasterchain commit interval, tonapi.io stream | 0.40 s | 0.48 s | 0.82 s | 99.65% (n=207598) |
| 5 | KaiaIstanbul BFT, block start to arrival | 0.50 s | 1.1 s | 1.5 s | 98.23% (n=84801) |
| 6 | CronosCometBFT, one height from previous commit | 0.58 s | 0.71 s | 1.2 s | 99.62% (n=196746) |
| 7 | BNBFast finality fork (BEP-126), measured via WS wall-clock | 0.76 s | 1.1 s | 14 s | 98.89% (n=189449) |
| 8 | Internet ComputerCertified state, block time to arrival | 0.95 s | 1.2 s | 1.7 s | 100.00% (n=168083) |
| 9 | AvalancheSnowman consensus, block production to accepted | 1.1 s | 1.3 s | 2.0 s | 97.74% (n=97571) |
| 10 | NEARBFT final block, nanosecond timestamps | 1.2 s | 1.3 s | 1.6 s | 99.93% (n=43100) |
| 11 | AlgorandRound time, proposal to certification | 2.8 s | 2.9 s | 3.0 s | 100.00% (n=30672) |
| 12 | StellarSCP federated voting, ledger close interval | 5.0 s | 5.0 s | 5.0 s | 100.00% (n=17279) |
| 13 | TRON19-block solidity confirmation | 57 s | 57 s | 1.0 min | 100.00% (n=2880) |
| 14 | EthereumCasper FFG, 2-epoch finalization | 15.8 min | 18.4 min | 19.0 min | 100.00% (n=2880) |
| 15 | Robinhood ChainArbitrum Orbit rollup, finalized by batch on its parent chain | 16.7 min | 17.2 min | 19.7 min | 99.34% (n=749390) |
| 16 | MoneroProbabilistic, 10 confirmations | 19.4 min | 28.8 min | 36.9 min | 100.00% (n=2880) |
| 17 | LitecoinProbabilistic, 12 confirmations, own clock | 31.0 min | 41.5 min | 51.5 min | 100.0% (n=492) |
| 18 | BitcoinProbabilistic, 6 confirmations, measured via own-clock polling | 47.5 min | 97.0 min | 166.5 min | 100.0% (n=160) |
Finality time by chain
Live p50 over the last 24 hours per chain, ranked lowest first. Each chain has its own consensus mechanism. The explainer below matches what the harness actually measures.
SUI finality time
0.25 s p50, 24h · Mysticeti DAG, measured via wall-clock checkpoint cadence.
SUI commits a checkpoint every 0.25 s (p50, 24h). Under Mysticeti a checkpoint is final when committed, so the interval between two checkpoints is how often finality lands. Measured from the checkpoints' own millisecond commit timestamps, read from the official GraphQL service every 500 ms and divided by the number of checkpoints committed in between.
Sei finality time
0.28 s p50, 24h · Single-slot BFT, header time to arrival.
Sei finalizes a block the moment it is committed, with no separate finalized tag. The figure, 0.28 s (p50, 24h), is the time from the block's header timestamp (nanoseconds) to its arrival on a `NewBlockHeader` subscription over the Tendermint WebSocket, already final. On Sei the header time read 0.2 to 0.3 s before arrival on 3 November 2026, inside one block interval of about 0.45 s, so it marks this block's proposal: the figure is proposal, votes, commit and delivery. Readings outside 0 to 60 s are dropped as clock skew.
Solana finality time
0.39 s p50, 24h · 98.8% success rate · Alpenglow, measured via WS wall-clock.
Solana finality time is 0.39 s (p50, 24h). Alpenglow replaced Tower BFT on mainnet on 21 October 2026: finality went from 32 confirmed slots, about 12.8 seconds, to a target of about 150 ms, and the confirmed and finalized commitments became one. The harness subscribes over WebSocket to slots and roots, records the wall-clock moment a slot first appears and the moment a root reaches it, and reports the difference in milliseconds. The slot appears while its block is still arriving, so the figure includes block propagation as well as the vote: over one hour on 24 October 2026, the block took about 165 ms to arrive in full and the vote about 242 ms to root (medians). The earlier method subtracted `getBlockTime` values, which are whole seconds and cannot resolve sub-second finality; it read 0 or 1 s after the switch and was retired on 22 October.
Gram finality time
0.40 s p50, 24h · Masterchain commit interval, tonapi.io stream.
Gram (the chain formerly branded TON, native token renamed Toncoin → Gram in June 2026) commits a masterchain block every 0.40 s (p50, 24h). Gram's docs treat a transaction as final once a masterchain block includes it, so the interval between two masterchain commits is how long finality takes to land. Measured as the wall-clock gap between consecutive masterchain seqnos on the tonapi.io block stream (a 300 ms REST poll stands in when the stream is unavailable, with intervals over 2 s dropped as poll aliasing). Workchain blocks become final once the masterchain references them.
Kaia finality time
0.50 s p50, 24h · 98.2% success rate · Istanbul BFT, block start to arrival.
Kaia's Istanbul BFT finalizes a block when it is committed. The producer waits until its parent's timestamp plus one second and starts the block then, with that whole second as its timestamp, so for an on-time block the timestamp is the start of block building. The figure, 0.50 s (p50, 24h), is that moment to the block's arrival on a `newHeads` WebSocket subscription. A late block gets a truncated timestamp with its fraction in `timestampFoS`, which newHeads does not carry; those blocks are not timed.
Cronos finality time
0.58 s p50, 24h · CometBFT, one height from previous commit.
Cronos (the EVM chain, built on CometBFT) finalizes a block when it is committed. The figure, 0.58 s (p50, 24h), is the time from the block's header timestamp to its arrival on a `NewBlockHeader` subscription over the Tendermint WebSocket. CometBFT header time is BFT time, the median of the validators' precommit times for the previous height, so the figure spans one full height: from the previous commit, through this block's proposal and votes, to its commit and delivery.
BNB Chain finality time
0.76 s p50, 24h · 98.9% success rate · Fast finality fork (BEP-126), measured via WS wall-clock.
BNB Smart Chain finalizes via the BEP-126 fast-finality fork, dropping the confirmation depth that legacy probabilistic chains require. p50 sits at 0.76 s (24h), measured via persistent WebSocket subscription that records T1 when block N first appears as `latest` and T2 when it crosses the finalized threshold. The WS approach gives millisecond precision on a chain whose block timestamps have 1-second granularity.
Internet Computer finality time
0.95 s p50, 24h · Certified state, block time to arrival.
An Internet Computer subnet finalizes a block, executes it, then threshold-signs the resulting state, and only certified state is served. A `read_state` answer carries the certified `/time`, the nanosecond batch time the block maker wrote into that block. The figure, 0.95 s (p50, 24h), is that time to the moment the certified state reaches us, polled every 250 ms on the NNS subnet (home of the ICP ledger), with the arrival taken at the midpoint between two answers. The certificate signature is not verified, since only the timestamp is used.
Avalanche finality time
1.1 s p50, 24h · 97.7% success rate · Snowman consensus, block production to accepted.
Avalanche C-Chain uses Snowman++ consensus and reaches finality at 1.1 s (p50, 24h). The Avalanche family targets sub-second finality through a sampled-voting protocol that converges with high probability after a few rounds of random validator queries. Measured from the block's own millisecond production timestamp to the moment it reaches us as `latest` over WebSocket. Since the 22 September 2026 upgrade the C-Chain runs Streaming Asynchronous Execution (ACP-194): a block is final when consensus accepts it, and the `finalized` RPC tag now means settled, a fixed 5 seconds later. Timing `latest` to `finalized` read about 6 s from that afternoon and was measuring the settlement delay, not finality; this figure replaced it on 24 October 2026.
NEAR finality time
1.2 s p50, 24h · BFT final block, nanosecond timestamps.
NEAR reaches BFT finality in 1.2 s (p50, 24h). Every NEAR header names `last_final_block`, the newest block with a finality certificate, normally two blocks behind it; RPC finality `final` returns that block. A block is final when the first block naming it is produced, so the figure is the timestamp of that block minus the final block's own timestamp, both in nanoseconds as set by the producers. Read every 2 s from dRPC's free NEAR endpoint: the optimistic head, plus its parent and its final block by hash, so the head is timed only when its parent named an older final block, which proves it is the first to name it.
Algorand finality time
2.8 s p50, 24h · Round time, proposal to certification.
Algorand has no unfinalized head: a node has a block only once its round is certified, so a block is final the moment it appears. The proposal for the next round starts once a round is certified, so one round, 2.8 s (p50, 24h), is the time from a block's proposal to its certification. Measured on our own clock as the interval between consecutive rounds returned by algod's `wait-for-block-after` long poll. Block timestamps are whole seconds, too coarse to time this from the chain.
Stellar finality time
5.0 s p50, 24h · SCP federated voting, ledger close interval.
Stellar uses the Stellar Consensus Protocol, a federated Byzantine agreement that reaches deterministic finality at every ledger close. Ledgers close every 5.0 s (p50, 24h). No probabilistic confirmation, no reorg window. Measured from the ledgers' own `closed_at` on the Horizon `/ledgers?cursor=now&order=asc` SSE stream, as the mean interval over the last ten closes (close times are whole seconds). Until 3 November 2026 the row timed ledgers as they arrived on the stream; Horizon delivers them unevenly (3.1, 4.0 and 7.1 s gaps between ledgers closed exactly 5 s apart), which put the median at 4.0 s and p90 at 11 s.
TRON finality time
57 s p50, 24h · 19-block solidity confirmation.
TRON's solidity confirmation hovers around 57 s (p50, 24h), the 19-block delay (two thirds of the 27 Super Representatives) at 3-second block intervals. The solidity flag in TRON consensus is the chain's equivalent of finalized: a block is irreversible once 19 Super Representatives have built on it. Measured via `/wallet/getnowblock` (head) minus `/walletsolidity/getnowblock` (solidity-confirmed).
Ethereum finality time
15.8 min p50, 24h · Casper FFG, 2-epoch finalization.
Ethereum finality time is 15.8 min (p50, 24h), measured live. Casper FFG finalizes a checkpoint two epochs after it is justified, where each epoch is 32 slots of 12 seconds, which puts the ideal case at about 12.8 minutes. Observed wall-clock finality runs longer because a block lands mid-epoch and waits before the two-epoch countdown starts. Finality is deterministic once reached, but reorgs of unfinalized blocks remain possible before finalization. Measured by polling `eth_getBlockByNumber("finalized")` against `latest` every 10 seconds and reporting the timestamp delta.
Robinhood Chain finality time
16.7 min p50, 24h · Arbitrum Orbit rollup, finalized by batch on its parent chain.
Robinhood Chain reaches the `finalized` tag in 16.7 min (p50, 24h). It is a rollup on the Arbitrum Orbit stack, not an L1: blocks arrive about every 100 ms, but a block is only finalized once the batch carrying it is posted to and finalized on the parent chain. Finality therefore lands in batches of about 10,000 blocks, and the figure is the median lag within each batch, measured from the moment a block is first seen as `latest` on a persistent WebSocket.
Monero finality time
19.4 min p50, 24h · Probabilistic, 10 confirmations.
Monero is a probabilistic chain with a 2-minute target block interval. Finality convention is 10 confirmations (a higher depth reflecting Monero's lower-throughput chain mining a smaller security budget), giving p50 = 19.4 min (24h). Measured via the monero-rpc `get_info` endpoint minus a 10-confirmation lookback through `get_block_header_by_height`.
Litecoin finality time
31.0 min p50, 24h · Probabilistic, 12 confirmations, own clock.
Litecoin is a probabilistic chain with a 2.5-minute target block interval. Finality is set by convention at 12 confirmations, giving 31.0 min (p50, 24h). Twelve, not the older 6: the 13-block MWEB reorg of April 2026 made 6 unsafe, and 12 is the deposit floor exchanges moved to. Measured like Bitcoin, on our own clock: the harness polls the tip height (`getblockcount` on Tatum's public JSON-RPC) every 30 seconds, T1 when a block first appears at the tip, T2 when the tip is 12 blocks past it. Block intervals are Poisson, so the wait varies widely around the 30-minute expectation.
Bitcoin finality time
47.5 min p50, 24h · Probabilistic, 6 confirmations, measured via own-clock polling.
Bitcoin is the reference probabilistic chain: Nakamoto consensus never declares a block final, confidence simply grows with confirmation depth. The exchange deposit convention is 6 confirmations, and this benchmark reports the wall-clock time to reach it, 47.5 min (p50, 24h). Bitcoin block timestamps are miner-set and may legally skew by up to two hours, so the harness does not trust them. It polls the mempool.space tip height every 30 seconds and uses its own clock: T1 when a block first appears at the tip, T2 when the tip is 6 blocks past it. Expect high variance; block intervals are Poisson, so the 6-confirmation wait ranges from about 30 minutes to well over 90. A block with 6 confirmations can still be reversed by a deeper reorg, with probability that vanishes as depth grows.
Frequently asked
What is blockchain finality?
Blockchain finality is the point at which a confirmed transaction cannot be reversed without breaking the protocol's security assumptions. Two finality models exist. Deterministic finality (Ethereum Casper FFG, Stellar SCP, Hedera Hashgraph) reaches an explicit consensus commitment that the network treats as irreversible. Probabilistic finality (Bitcoin, Litecoin, Monero, Cardano) leaves a non-zero reorg probability that decreases exponentially with confirmation depth. This benchmark measures the wall-clock time each chain needs to reach its native finality threshold.
Probabilistic vs deterministic finality, what is the difference?
Deterministic finality is a binary state. A block is either finalized or it is not, and finalized blocks cannot be reorganized. Probabilistic finality is a confidence curve: a block becomes more final with each confirmation that builds on top of it. Exchanges set a convention (Bitcoin 6, Litecoin 6, Monero 10, Cardano 15) past which they treat funds as settled, but the protocol itself never declares strict finality. This benchmark uses each chain's native convention rather than imposing a uniform depth across all chains.
What is Ethereum finality time?
Ethereum finality time measured live on this page is 15.8 min (p50, 24h). Casper FFG finalizes a checkpoint two epochs after it is justified, where each epoch is 32 slots of 12 seconds, about 12.8 minutes in the ideal case. Observed wall-clock finality runs longer because a block lands mid-epoch and waits before the two-epoch countdown starts. The live table above shows the measured value. The benchmark polls eth_getBlockByNumber("latest") and eth_getBlockByNumber("finalized") every 10 seconds and reports the timestamp delta.
What is Solana finality time?
Solana switched consensus from Tower BFT to Alpenglow on 21 October 2026 (epoch 1064). Under Tower BFT a block was finalized after 32 confirmed slots, about 12.8 seconds; Alpenglow targets about 150 ms and makes confirmed and finalized the same thing. Measured here as the wall-clock time from a slot first appearing to it being rooted, 0.39 s (p50, 24h). That figure has two parts: the block still arriving after the slot first appears (about 165 ms at the median on 24 October 2026), then voting from the complete block to root (about 242 ms).
What is Gram finality time?
Gram (the network formerly branded TON, native token renamed Toncoin → Gram in June 2026) commits a masterchain block every 0.40 s (p50, 24h). A transaction is final once a masterchain block includes it, so the interval between two masterchain commits is how long finality takes to land. Gram splits state across a masterchain and many workchains; the figure here is the masterchain, the canonical reference for cross-chain settlement.
What is Stellar finality time?
Stellar uses the Stellar Consensus Protocol, a federated Byzantine agreement that reaches deterministic finality at every ledger close, no probabilistic confirmation needed. The interval between two closes is 5.0 s (p50, 24h), read from the ledgers' own close times on the Horizon stream and averaged over the last ten closes, since each close time is whole seconds.
What is BNB Chain finality time?
BNB Smart Chain finalizes via the BEP-126 fast-finality fork, dropping the confirmation depth that legacy probabilistic chains require. p50 sits at 0.76 s (24h), measured via persistent WebSocket subscription that records T1 when block N first appears as latest and T2 when it crosses the finalized threshold.
Which blockchain has the fastest finality time?
Sub-second BFT chains lead: SUI posts the lowest median at 0.25 s (p50, 24h). BNB follows at 0.76 s and Avalanche at 1.1 s via their fast-finality forks. Solana finalized clocks 0.39 s and Ethereum 15.8 min. Probabilistic chains trail by confirmation-depth convention: Litecoin at 31.0 min and Bitcoin at 47.5 min for 6 confirmations.
What is Bitcoin finality time?
Bitcoin never reaches absolute finality. Nakamoto consensus gives probabilistic finality: any block can in principle be reorganized, with a probability that falls exponentially as more blocks are mined on top. The exchange-industry deposit convention is 6 confirmations, roughly one hour at the 10-minute target block interval, and that is what this benchmark measures: 47.5 min (p50, 24h) wall-clock from a block first appearing at the chain tip to reaching 6 confirmations, timed with the harness clock rather than miner-set block timestamps. Variance is high because block intervals are Poisson distributed; a lucky streak settles in about 30 minutes, an unlucky one takes well over 90. Six confirmations is a risk threshold, not a protocol guarantee, and deep reorgs remain possible with vanishing probability.
What is NEAR finality time?
NEAR keeps a head (optimistic) and a final block, the newest one with a BFT finality certificate, normally two blocks behind. Every header names that final block. Measured here as the time from a block's own timestamp to the timestamp of the first block naming it final, both in nanoseconds: 1.2 s (p50, 24h).
Why are Hedera, Aptos and Somnia not on the board?
None of them exposes a public signal that separates a block's proposal from its finality. Hedera finalizes in a documented 3 to 5 seconds through Hashgraph aBFT, but its mirror nodes only publish already-final records, stamped with the consensus time, the moment of finality itself; Block Nodes (HIP-1056) would expose more once they leave private preview. On Aptos and Somnia every block an RPC serves is already final. Somnia timestamps are whole seconds on blocks about 100 ms apart, too coarse for sub-second finality. Aptos timestamps are microseconds, but on 3 November 2026 they read within one network round trip of arrival, often after our request had left, so they do not mark the proposal.
How is L1 finality time measured on this page?
Four methods, picked per chain. Where a head and a final block coexist, T1 is when block N first appears and T2 when it is final: over WebSocket on BNB, Robinhood Chain and Solana, on block timestamps polled every 10 seconds on Ethereum, TRON and Monero, on NEAR's nanosecond timestamps, and on our own clock at the tip for Bitcoin and Litecoin. Where every block is final when it appears, the figure is the block's own timestamp to its arrival: Avalanche, Sei, Cronos, Kaia and the Internet Computer's certified time. Stellar, Gram, SUI and Algorand report the interval between two final blocks, ledgers, checkpoints or rounds.
Source code github.com/ChainBench/OpenChainBench/tree/main/harnesses/l1-finality