A transaction shows up in a block, your wallet says confirmed, and you move on. But on most chains that confirmation is not the same as settled. Finality is the point where a transaction can no longer be reversed, and until a block reaches it, a reorganisation can still drop it from the chain. The wait is not the same everywhere: on some chains it is seconds, on Ethereum it is about thirteen minutes, and on proof-of-work chains it is never absolute, it only gets safer with every confirmation that piles up on top.
This matters most when money moves between systems. An exchange crediting a deposit, a bridge releasing funds on another chain, or an app acting on a payment all need to know when it is safe to act. Act before finality and a reorg can leave you having paid out for a transaction that no longer exists. Getting finality right is therefore an operations decision, not just a theory question. Our consensus explainer covers how chains agree in the first place, and this post builds on it with the practical question of when that agreement becomes permanent.
Finality in one paragraph
Finality means a block and everything before it is locked in, so no reorganisation can remove it under the normal rules of the protocol. Before finality, a block is a candidate: it is the head of the chain for now, but a competing fork could still replace it. After finality, replacing it would require breaking the protocol itself, which on a proof-of-stake chain means destroying a large share of the staked funds. That is why finality is usually described as economic: it is not a mathematical proof that reversal is impossible, it is a guarantee that reversal costs more than any attacker could gain from it.
There are three shapes of finality in use today. Probabilistic finality, used by proof-of-work chains, gets stronger with each confirmation but never reaches one hundred percent. Deterministic finality, used by proof-of-stake chains such as Ethereum, reaches a definite point after which the block is final. Instant finality, used by BFT chains such as Cosmos, settles a block the moment it is committed. The rest of this post takes each one in turn, with the numbers that define it.
Probabilistic finality: proof of work and confirmations
On a proof-of-work chain, two miners can find a block at nearly the same time, and the network briefly splits into two competing versions of history. Nodes follow the chain with the most accumulated work, and the losing fork is abandoned, taking its transactions with it. A transaction in an abandoned block is not lost forever, it usually returns to the mempool and gets mined again, but anything that already acted on it has a problem. This is why proof-of-work finality is probabilistic: each new block on top makes a reorg less likely, because an attacker would need to redo all that work, but the probability never reaches zero.
The practical answer is confirmations. A confirmation is one more block built on top of yours, and services pick a number that matches the value at stake. There is no single correct number: the threshold is a risk decision, not a protocol rule. If you run infrastructure for an exchange or a bridge, the confirmation threshold belongs in your runbook, written down with the reasoning, not left as a default somebody set once and forgot.
Deterministic finality: how Ethereum settles a block
Ethereum is the clearest example of deterministic finality, and its numbers are public and stable. Time on the consensus layer is divided into 12-second slots, and 32 slots make one epoch of about 6.4 minutes. The first block of each epoch is a checkpoint, and finality voting targets checkpoints, not every block. Validators vote on pairs of checkpoints, and when validators holding at least two-thirds of all staked ETH vote for a checkpoint, it becomes justified. When the next checkpoint is justified on top of it, the earlier one becomes finalized. Under normal conditions that takes about two epochs, roughly 12.8 minutes from inclusion to final.
Casper FFG, the friendly finality gadget, turns validator votes into finality, while LMD-GHOST picks the head of the chain between checkpoints. Together they are called Gasper. The security argument is economic: reversing a finalized checkpoint would require conflicting votes that get slashed, costing attackers at least one-third of all staked ETH. For the mechanics behind the votes, see our proof-of-stake explainer and our slashing guide.
Block explorers usually show three states that map directly to this process: unfinalized, safe, and finalized. If you are building anything that reacts to chain events, wait for finalized for high-value actions and safe for low-value ones, and make that choice explicit in your code, not implicit in a sleep timer. Ethereum also has single-slot finality on its roadmap, aiming to finalize blocks in about 12 seconds instead of two epochs, but that is a roadmap item, not live behaviour, so do not build on it yet.
Instant finality: BFT chains settle in one block
Chains built on BFT consensus, such as Cosmos Hub with CometBFT, take a different approach: a block is final the moment it is committed. Validators propose a block, then vote on it in rounds, and once more than two-thirds of validators precommit it, the block is locked in immediately. There is no waiting period and no confirmation count, because the vote that creates the block is the same vote that finalizes it. As long as more than two-thirds of validators are honest, a finalized block cannot be reverted without those validators breaking the rules and being punished for it.
The trade-off is validator set size. BFT voting needs every validator to talk to every other validator in each round, which works well with a bounded set and gets harder as the set grows. That is why Cosmos Hub runs with an active set of 180 validators, set by governance. For an operator this changes what to monitor: on a BFT chain, missed votes and slow precommits are the early warning of finality problems, and a validator that stops voting slows settlement for the whole network.
What finality means for operators, exchanges, and apps
Finality shapes real infrastructure decisions in four places. First, deposits and withdrawals: an exchange that credits deposits at one confirmation on a chain with slow finality is taking reorg risk on every deposit, and the fix is a confirmation policy per chain, written down and tested. Second, bridges: a bridge that releases funds on the destination chain before the source transaction is final is the classic bridge failure, and the fix is to wait for finality on the source chain, even when users complain about the delay. Third, RPC and indexers: an indexer serving unfinalized blocks must handle reorgs, while one serving only finalized blocks is simpler but lags the head. Fourth, monitoring: a node that falls behind the finalized checkpoint is in worse shape than a node that is merely a few blocks behind the head, because it cannot serve anything trustworthy at all.
If you run nodes for others, put finality in your status page and your alerts. Track the gap between your node's finalized checkpoint and the network's, not just the head, and alert when that gap grows. Our Grafana monitoring guide covers the metrics to watch, and finality lag belongs on that dashboard next to block height and peer count.
Common mistakes, and the checklist that prevents them
A short checklist covers most of it. Know the finality model of every chain you support, and write down the numbers. Set confirmation and finality thresholds per chain, per value, and test them. Serve finalized data by default, and label unfinalized data as unfinalized wherever it appears. Alert on finality lag, not just on head lag. And rehearse a reorg: know what your indexer, your bridge, or your exchange does when a block it already processed disappears, before it happens in production. If that last item has no answer, that is the most urgent gap, because reorgs are a matter of when, not if.
Finality is one of those ideas that sounds academic until it costs real money, and then it is the only thing that matters. A settled transaction is one nobody can take back, and every system that moves value between chains is, underneath, a system for waiting until settlement is real. If your team runs nodes or RPC for a product that touches deposits, bridges, or cross-chain flows, see our node setup and node operations pages, or start with a free infra audit and we will check your finality handling along with the rest of the stack.
Disclaimer: This post is educational only, not financial advice. Figures are listing or project data as of 2026-11-06 and may change - always confirm version numbers, requirements, and dates in the official docs before acting on them.
