What Ethereum Actually Is: A Shared Computer, a Meter, and a Burned Bill

I rented nothing and trusted nobody. On 2026-09-29, at 08:10 UTC, I opened one public execution endpoint and one public beacon node and asked them for the bill. The execution client answering was reth/v2.5.2; the consensus client was Lighthouse/v8.2.2. The chain id was 1. The latest block was 26,081,835, stamped 08:09:59, and the fee it charged was a base fee of 0.500091605 gwei. The endpoint’s own gas-price call agreed, roughly: about 0.5 gwei. The priority tip it suggested was 1 wei. One wei. The blob fee was 0.0273 gwei per unit of blob gas. That is the whole receipt, and almost everything below is me explaining what those numbers pay for.

One caveat: these were single nodes, one execution client and one beacon node, not the whole network, and a single node can be wrong or lagging. I hand you the method at the end so you can catch me.

The fee is not a toll on money; it is rent on a computer the whole network shares

Ask a stranger what Ethereum costs and you will get a price ticker. Wrong instrument. A fee here is not a price for moving value. It is rent on a computer everyone shares, and the computer runs only if enough strangers agree on the result.

Follow the money. The base fee, 0.500091605 gwei per unit of gas, is not set by a company and is not paid to a company. The protocol computes it, every block, from how full the previous block was, then destroys it. The priority fee — the tip — is the part a human being receives, and on the day I looked the network was suggesting 1 wei of it. One wei is not a bribe; it is a formality. So on a quiet morning, the largest line on the bill is the one nobody collects.

I am not here to sell you the chain. Most of what is written about it is a brochure or a warning label, and this is the bill underneath both.

Twelve blocks, 132 seconds, and a perfect metronome

I watched twelve consecutive blocks, 26,081,828 through 26,081,839, spanning 132 seconds. Every one of the eleven intervals between them was exactly 12 seconds. Not on average — every one. The block time is not a market outcome; it is a constant in a config file, and the machine keeps it.

Across those twelve blocks the chain carried 3,195 transactions, which is 24.2 per second on layer 1, at an average of 117,175 gas each. Now the load. One block, 26,081,836, used 59,995,226 gas — 100.0 percent of the 60,000,000 limit. It was full. The block before it carried 179 transactions and used 16.9 percent. That is a sixfold swing in one slot. Layer-1 capacity is not a pipe of fixed width; it is a room that fills and empties, and the price is the valve.

Blob usage swung too, from 0 to 1,703,936 blob gas. The block I first read carried 524,288 blob gas, which is 4 blobs. Hold that number; it returns below.

Who decides what one unit of gas is worth?

Gas is the meter, not the price. A plain value transfer costs exactly 21,000 gas, and that figure is written into the rules, not estimated. A storage write costs thousands; adding two numbers costs three. The machine charges for work done and state changed, never for the dollar amount moved. Send one coin or a million: same 21,000, as long as the transaction is a plain transfer.

The price of one unit of gas is a separate decision, and since August 2021 the protocol makes it itself. The rule has a name and a paper, and the paper’s own summary is blunt:

A transaction pricing mechanism that includes fixed-per-block network fee that is burned and dynamically expands/contracts block sizes to deal with transient congestion.

EIP-1559, Simple Summary

Two ideas sit in there that most people get backwards. First, the fee is burned, which means the biggest part of it goes to no one. Second, the block size is elastic: the system does not cap transactions, it raises the price when blocks run hot and lowers it when they run cold. You can read the whole rule at the EIP-1559 specification, the pricing rule the network now runs on.

Here is the sequence your money follows, in the order it happens:

1. Your wallet signs the transaction and broadcasts it to the network.
2. Nodes check the signature and the balance and hold the transaction in a pool.
3. A builder assembles a block and orders the transactions, usually by how much tip each one pays.
4. Execution charges gas per opcode and per state change, exactly as the rules dictate.
5. Whatever gas you did not use is refunded to you.
6. The base fee is burned and the tip goes to the block producer.

A limit here is a knob somebody keeps turning, and the turning is published

Most people treat a blockchain limit as a law of nature. It is a parameter, and this system publishes the schedule of times it gets raised. The config on the node I read carries a list called BLOB_SCHEDULE with exactly two entries. Epoch 412,672 sets the maximum blobs per block to 15. Epoch 419,072 raises it to 21. The head epoch when I measured was 478,764, so both steps have already fired. The working ceiling is 21 blobs per block.

Now the trick. The same config still carries named constants that say 6, and then 9. Those are fossils. The number actually enforced comes from the schedule, not the constant. I watched a real block carry 1,703,936 blob gas, which is 13 blobs — above the ancient constant, below the scheduled ceiling. The named number is a memory; the schedule is the law.

The same habit shows up everywhere. The block gas limit was 60,000,000 in every block I sampled, a line in the config, not a physical fact. A new block arrives every 12 seconds because SECONDS_PER_SLOT says 12. When the rules themselves change, they change through versioned forks, each carrying the epoch it switched on: at 0, 74,240, 144,896, 194,048, 269,568, 364,032, and 411,392 — six changes since genesis. The newest activated at 411,392; the head epoch, 478,764, is 67,372 epochs past it. If you want the dates attached to the next one, this site keeps them: Ethereum’s next hardfork and the dates attached to it.

Accounts, one global state, and a machine that edits it

This is where Ethereum stops being Bitcoin with extra steps. Bitcoin’s model is UTXO: coins exist as discrete outputs, a transaction destroys some and creates others, and there is no single balance sheet. Ethereum keeps accounts and balances over one global state, and that single change is what makes a general-purpose computer practical on top of it.

In a standard banking system, for example, the state is a balance sheet, a transaction is a request to move $X from A to B, and the state transition function reduces the value in A’s account by $X and increases the value in B’s account by $X.

Ethereum whitepaper, 2013

That is not a metaphor. One shared state, a transaction is a request to change it, and a state transition function applies the change. The 2013 paper went further: the point was to put a general programming language on that state so anyone could write new transition functions — not just move coins, but define what a coin is.

And the machine itself is small and strange. The whitepaper says the code in Ethereum contracts is written in a low-level, stack-based bytecode language, referred to as “Ethereum virtual machine code” or “EVM code”. The state is a ledger; the virtual machine edits it; every full node runs the same machine over the same state and gets the same answer. That is how thousands of computers that do not trust each other still agree on one number.

Follow the stake, and count who actually shows up

Proof-of-stake is not mining with a different name. There is a registry of validators, each with money locked, and each slot some are chosen to propose a block and the rest to attest to it. The config fixes the rules of the club; here are six lines that decide who is inside.

The registry’s highest existing index was 2,375,086, found by binary-searching until the next one returned an empty list. That newest validator has an effective balance of 32 ETH, a status of pending_queued, and an activation epoch of 18,446,744,073,709,551,615 — the largest unsigned 64-bit integer, how the spec writes not yet. It is queued, not active. Index 500,000 also exists, with status withdrawal_done and a balance of zero. Indices are permanent and never reused: the registry does not erase names, only balances.

Finality is the part people skip. Validators attest to checkpoints, and a checkpoint becomes final once two consecutive epochs have enough support. When I looked, the finalized epoch was 478,762, justified was 478,763, and the head sat in 478,764 — finality trails the head by exactly two epochs, 64 slots, about 12.8 minutes. The beacon chain genesis was 2020-12-01 12:00:23 UTC; the head slot was 15,320,448, and at 12 seconds a slot that is about 5.83 years, landing on the day I measured. The clock has not slipped. Reverting a finalized checkpoint would take an attacker burning at least a third of all the staked money — the entire security argument in one sentence. What that stake pays out is measured elsewhere on this site: what the staking economy pays out.

Why two programs from two different teams?

Reth answered my execution calls; Lighthouse answered my consensus calls. Two different programs from two different teams, talking over a wire, and that split is the point. Before September 2022 the execution rules and the consensus rules were one thing, and who got to write was decided by miners doing hashes. The Merge pulled them apart: the consensus layer is the beacon chain that launched in December 2020, running proof-of-stake and deciding who proposes what; the execution layer runs the EVM and holds the state.

You can replace one without the other. That is not an aesthetic choice; it is upgrade safety. If the execution client has a bug, the consensus client still keeps the chain honest about who is allowed to write, and the reverse holds too.

The deposit contract at 0x00000000219ab540356cbb839cbe05303d7705fa is the seam between them: the execution layer watches it for new deposits, and the consensus layer turns them into validators. A leftover, SECONDS_PER_ETH1_BLOCK = 14, is a scar from when the consensus layer followed a separate deposit chain. The two layers remember being one.

The open question, and the receipts you can pull yourself

None of this requires trusting me. Every number above came from two public endpoints, and you can pull the same receipts. Here is the method:

1. Point any client at a public execution RPC and request the latest block by number.
2. Read baseFeePerGas, eth_gasPrice, eth_maxPriorityFeePerGas and eth_blobBaseFee from that same block.
3. Walk back twelve blocks and compare their timestamps to confirm the 12-second spacing yourself.
4. Ask a beacon node for the head slot, the finalized epoch, and the current justified epoch.
5. Binary-search the validator index space until an entry comes back empty.

One thing I will not tell you is that this is settled. The fee now has two jobs at once: it pays block producers and it burns supply, and the ordering of transactions is decided by builders who can extract value from that ordering. Whether that arrangement keeps the network secure and honest over decades is genuinely unresolved, and anyone who tells you it is solved is selling something. I measured the fees; I did not measure the future.

What I can hand you is the machine as it stood that morning. An account-based state ledger, one shared balance sheet, edited by a general-purpose virtual machine. A fee metered by work, priced by formula, and mostly burned. Twelve-second slots, validators who attest and are paid, finality two epochs behind the head, blobs for the rollups that carry the load. The receipt was small that day, a tip of one wei, because the room was mostly empty. It will not stay empty, and it was never free. That is not a price; it is the cost of the machine, and now you can read it yourself.