Foundations — Why Ethereum Exists

This is page one of the book, so it is also page one of the argument. Before we open a single opcode, wire an account, or price a byte of storage, we have to answer a question that everything else in the book depends on: why does a programmable blockchain exist at all? Bitcoin already lets untrusting strangers agree on who owns what. Ethereum spends enormous complexity to do more — and this part exists to make you feel exactly what that “more” is, and why it was worth the cost, before you meet the machinery that pays for it.

So here is the question the whole book turns on, stated once and returned to on every page:

How do untrusting strangers agree on the state of a shared world computer — and what does it cost to run one?

Each clause is load-bearing. Untrusting strangers rules out a trusted server. Agree means every one of them must compute the identical result. A shared world computer — not just a ledger of coins — is the leap this part explains. And what does it cost is the thread that runs from here all the way to the gas schedule: a public machine that runs anyone’s code cannot run it for free, so cost is not a footnote, it is the design.

The leap this part explains

Bitcoin is a ledger that moves value. You can express who may spend a coin (a signature, a set of signatures, a timelock, a hash preimage), but the ledger’s job is finished the moment the coin lands in the next owner’s hands. It does one thing, deliberately, and refuses to do more.

Ethereum asked a bigger question: what if the shared ledger could run arbitrary programs? Not “who owns which coin” but “what is the current state of this world computer, and what code is allowed to change it.” That single change in ambition pulls in a completely different design — accounts instead of coins, a mutable world state instead of a coin set, a virtual machine instead of a fixed script — and it opens a whole new surface of things that can be built and things that can break.

   BITCOIN                                 ETHEREUM
   a ledger that moves value               a ledger that runs programs

   "who may spend this coin?"              "what is the world's state,
                                            and what code may change it?"

   spending conditions (Script)            a Turing-complete VM (the EVM)
   deliberately cannot loop                loops allowed — tamed by gas
   state = the set of unspent coins        state = every account + its storage
   finished when the coin moves            remembers and evolves forever

That is the leap: from a ledger that only moves value to a ledger that runs arbitrary programs against a single shared state. Everything in this book — accounts, the EVM, gas, tries, consensus, rollups — is a consequence of taking that leap seriously and paying for it honestly.

The throughline, in one breath

The five pages of this part make one argument, in order:

A ledger is already a tiny state machine — a function that takes the current world and a transaction and returns the next world. Once you see a ledger this way, “run a program on the ledger” stops sounding exotic.
Bitcoin’s scripting is deliberately limited — no loops, hard caps, provable halting — because a public verifier must be able to afford to check every transaction. Those limits are a feature, not an oversight.
Ethereum generalizes the ledger into a world computer: keep the deterministic state-transition function, but let the “program” be arbitrary code running against mutable, shared storage.
Arbitrary code can loop forever, and no one can prove in advance that it halts — so ether is the fuel that meters every step. Gas turns the halting problem from an unsolvable logic question into a solved economic one: you don’t prove termination, you make non-termination unaffordable.

Hold those four moves together and “smart contract” stops being a buzzword. It becomes what it actually is: a few bytes of code living in an account, run by a metered loop against a storage cell, producing a next world that every node computes identically.

Roadmap for this part

Read these in order. Each page introduces one idea and hands it to the next.

#	Page	The idea it introduces	Feeds into
2	A Ledger Is Already a State Machine	a ledger is a deterministic function: `(world, tx) → world'`	every later page — this is the frame
3	Bitcoin’s Deliberate Limits	why Script forbids loops so a public verifier can always afford to check	the gap that motivates a fuller machine
4	Generalizing the Ledger into a World Computer	keep the state-transition function, let the program be arbitrary code	the need for a halting bound
5	Ether as Fuel	gas meters every step; ether pays for computation, not just transfers	the whole rest of the book
900	Revision — Why Ethereum Exists	the four moves recapped as one argument	—

Notice the dependency chain: page 2 gives you the frame (a ledger is a function), page 3 shows the deliberate ceiling Bitcoin puts on that function, page 4 raises the ceiling to arbitrary code, and page 5 shows the bill that raising it creates. Remove any one link and the argument breaks — which is exactly why they are ordered this way.

The thread

This part stays at the why altitude on purpose. We are drawing the map, not walking every street. You will hear names — the EVM, gas, accounts, the state root, proof-of-stake — but we do not prove their mechanics here. Each has its own part later in the book where it is built from first principles and, wherever possible, coded against the companion crate:

Accounts and the world state — the mutable map that replaces Bitcoin’s coin set — get built in Accounts & State.
The state root — how 32 bytes commit to gigabytes of world — is the whole job of State & the Merkle-Patricia Trie.
The EVM and gas — the metered machine and its price list — are proven in the EVM and Gas & Fees parts, and you build a tiny one in Build Your Own EVM.
Consensus and scaling — how strangers actually converge, and how the network grows past its base-layer limits — arrive in Consensus and Scaling.

So when this part says “gas meters every opcode,” take it as a promissory note, not hand-waving: the Gas & Fees part cashes it in with the real schedule and a worked bill. The job here is only to make you want that detail — to see, from first principles, why a world computer cannot exist without a fuel gauge.

This part deliberately quotes almost no figures, because a why page that leans on volatile numbers ages badly. One durable contrast is worth keeping in your head, though, because it captures the whole cost story in two lines. On Ethereum the base cost of including any transaction at all is a fixed 21,000 gas, and the single most expensive common operation is not arithmetic but writing a brand-new storage slot — roughly 20,000 gas — because every node on Earth must then store that data essentially forever.

   plain value transfer      :  21,000 gas   (the floor for any tx)
   write a NEW storage slot   :  ~20,000 gas   (every node persists it forever)
   a simple arithmetic op     :  ~3 gas

   lesson: the dearest thing a world computer does is REMEMBER,
           because remembering is a cost it imposes on every stranger.

That single pattern — remembering is expensive because it is a burden dumped on every participant — is the seed of the entire fee model. We plant it here and harvest it in Gas & Fees. (Gas amounts are protocol constants and stable across recent forks as of 2024; the fee in dollars is not, which is exactly why we quote gas, not price.)

What “a world computer” really claims

It is worth being precise about the phrase, because it is easy to hear as marketing. A “world computer” is not fast, not cheap, and not private. It is something stranger and more specific: a computer whose state is agreed by mutually distrusting parties who never chose to trust each other. Every node runs the same code against the same inputs and must reach the same output, or the network forks. That replication is the source of every property people care about (no one can quietly alter the ledger) and every cost people complain about (every node redoes every computation).

So the “world computer” is slow by construction: its slowness buys the agreement of strangers. Keep that trade in view and the rest of the book reads as one long answer to a single question — how much can we make this shared machine do, and how little can we make it cost, without ever losing the property that strangers agree on the result?

That question is where we begin. Turn to A Ledger Is Already a State Machine — because once you see a plain ledger as a state-transition function, running a program on it is no longer a leap. It is the obvious next move.

Check your understanding

State the book’s driving question in one sentence, and explain why the phrase “untrusting strangers” rules out the simplest possible design (a trusted server).
In one line each, describe the leap this part explains: what does Bitcoin’s ledger do, and what does Ethereum’s ledger do that is fundamentally more?
The throughline has four moves (ledger-as-function → deliberate limits → generalize to code → fuel). Why must “fuel” come after “generalize to arbitrary code” and not before?
This part quotes gas amounts but avoids quoting fees in dollars. Give the reason, and name the one durable cost pattern the “By the numbers” box highlights.
The page calls a world computer “slow by construction.” What does its slowness buy, and why is that trade the whole subject of the book?

Show answers

How do untrusting strangers agree on the state of a shared world computer — and what does it cost to run one? “Untrusting strangers” means no participant can be assumed to trust any other, which rules out a trusted server (that would require everyone to trust its operator); instead every node must be able to independently compute and verify the same result, which is what makes agreement possible without trust.
Bitcoin’s ledger moves value — it records who owns which coins and enforces who may spend them, and its job ends when a coin changes hands. Ethereum’s ledger runs arbitrary programs against a single shared, mutable state — it tracks not just balances but the evolving storage of any contract anyone deploys.
Because “fuel” (gas) only becomes necessary once the program can loop. Bitcoin’s limited scripting provably halts, so it needs no fuel gauge; the moment you allow arbitrary, possibly-non-terminating code (move 3), you inherit the halting problem, and metering every step (move 4) is the answer to it. Fuel is the consequence of generalization, so it must follow it.
Fees in dollars depend on volatile price and demand and would age badly on a why page, whereas gas amounts are stable protocol constants (as of 2024). The durable pattern: remembering is the most expensive thing a world computer does — writing a new storage slot costs far more than computation because every node must persist that data essentially forever, so cost tracks the burden an operation imposes on every participant.
Its slowness buys the agreement of mutually distrusting strangers: every node re-runs every computation so no one has to trust anyone, and the ledger cannot be quietly altered. That trade — maximum agreement at the cost of massive redundant work — is exactly what the whole book measures: how much the shared machine can do, and how little it can cost, without ever losing that agreement.