Assume Valid (assumevalid)

Assume Valid, controlled with the -assumevalid option, is a Bitcoin Core feature that lets a node skip the single most expensive part of validating old blocks — verifying every digital signature and script — for blocks that came before a specific, hard-coded "known to be good" block hash. It exists to make initial block download dramatically faster without weakening the security model, and understanding why it is safe is worth the effort.

How it speeds up sync

A large share of the time a fresh node spends syncing from scratch goes into checking the cryptographic signatures on years of historical transactions. The assume-valid block is a recent, deeply buried block whose hash ships inside the Bitcoin Core source code in the chainparams file, set by the developers and reviewed in the open. For blocks that are ancestors of that hash, the node still checks that all data hashes correctly, that no coin is created from nothing, and that no output is spent twice; it only skips re-verifying the signatures — work that thousands of other nodes have already done. Blocks that are not yet buried under sufficient proof of work are always fully validated, signatures included, so anything recent gets the full treatment.

The reasoning behind why this is safe rests on the sheer weight of the historical chain. By the time a block is thousands deep, rewriting the history before it would require redoing an astronomical amount of proof of work, so an attacker cannot cheaply present a fake past that happens to end at the shipped hash. The signatures on those ancient transactions have also been checked independently by an enormous number of nodes over the years; re-checking them on your one machine adds confidence but not new security, which is exactly why skipping that specific step is defensible while skipping the accounting checks would not be.

It is a performance optimization, not a checkpoint

The crucial point for anyone reasoning about trust: assumevalid has no influence on consensus. It does not tell the node which chain is valid. If you point it at a hash sitting on an invalid history, the node will still reject that chain the moment full validation catches a real rule violation. It is not deciding which coins are real; it is only deciding where to spend CPU. This is what separates it from the old-style hard-coded checkpoints Bitcoin used long ago: those actually constrained which chain the software would accept, whereas assume-valid is a speed setting you can audit line-by-line in the source or switch off entirely.

For maximum-verification operators

If you want to verify the entire history yourself, set -assumevalid=0 and the node will check every signature from the genesis block forward. It costs more time and CPU, but it is the strongest possible stance and a reasonable one for a sovereign operator who trusts no default. It is worth stressing what assume-valid is not: it is not a claim about whether particular coins are yours, not a trust assumption about balances, and not a shortcut that could let an attacker slip an invalid chain past you. Related node-scaling options approach the same "sync faster, verify what matters" goal from other angles — AssumeUTXO bootstraps a node from a snapshot of the spendable set while background validation catches up, and a pruned node discards old block data after fully validating it.

Keeping the assumption honest

Because the assume-valid hash lives in the source code, it inherits Bitcoin Core's open review process: each release, the value is proposed, discussed, and can be independently reproduced by anyone building the software. A user who distrusts a given release can compare the hash against other sources, override it, or disable it. That auditability is the whole reason the optimization is considered compatible with Bitcoin's trust-minimizing ethos — nothing is hidden, and every shortcut it takes is one you can refuse. In short, it buys a large speed-up on a fresh sync in exchange for trusting only that a widely reviewed, easily checked recent block is genuine, and it hands you a one-flag off-switch if you would rather trust nothing at all.