Bitcoin's ledger tracks who owns how many coins. Ethereum's ledger does something far more powerful: it runs programs. This lesson explains the model that makes that possible — Ethereum as a single, shared 'world computer' whose state everyone agrees on, the two kinds of account that live in it, how transactions change its state, and how gas meters the whole thing. Get this model straight and smart contracts, which come next, will feel like a natural extension rather than a mystery.
- Explain Ethereum as a shared state machine — the 'world computer' and the EVM
- Distinguish externally owned accounts from contract accounts
- Describe how a transaction changes global state, and the role of the nonce
- Read gas, ether units, and the base-fee model at a working level
Two kinds of account
Everything on Ethereum is an account, and there are exactly two types. An externally owned account (EOA) is controlled by a private key — this is a user's wallet. It has a balance and can *start* transactions by signing them. A contract account is controlled by its code, not a key. It has a balance and, crucially, its own persistent storage, and it runs its code whenever a transaction calls it. It cannot start a transaction on its own; it only acts when triggered. The distinction is fundamental: EOAs are the users who initiate action, contracts are the programs that respond. A smart contract is simply the code and storage sitting at a contract account's address.
| Property | Externally owned (EOA) | Contract account |
|---|---|---|
| Controlled by | A private key | Its own code |
| Can start a transaction | Yes (by signing) | No — only reacts when called |
| Has a balance | Yes | Yes |
| Has code and storage | No | Yes — persistent on-chain state |
State, transactions and the nonce
A transaction is a signed instruction from an EOA that changes state: sending ether, deploying a contract, or calling a contract's function. Each transaction includes the sender, the recipient (an address or a contract), any ether value, optional data (which function to call and with what arguments), and gas settings. Every EOA also has a nonce — a counter of how many transactions it has sent. The nonce forces transactions from one account to be processed strictly in order and exactly once, which prevents someone from replaying an old signed transaction to, say, drain your account twice. If your first transaction is stuck, later ones wait behind it, because each nonce must be used in sequence.
transaction {
from: 0xAlice... // an EOA, identified by signature
to: 0xContract... // an EOA (send ether) or a contract (call it)
value: 0.1 ETH // ether to transfer, if any
data: mint(5) // which function + args, if calling a contract
nonce: 7 // Alice's 8th transaction (0-indexed)
gas: { limit, maxFee, priorityFee }
}
// The network applies this to the world state, in nonce order, exactly once.Gas and the fee model, a little deeper
You met gas in the last lesson: gas measures computational work, and you pay for it. Ethereum's current fee model (introduced by EIP-1559) splits the price into two parts. A base fee is set automatically by the network based on how full recent blocks were — it rises when demand is high and falls when it's low, and it is *burned* (removed from supply). On top, you add a priority fee (a 'tip') to incentivise validators to include your transaction sooner. You also set a gas limit: the maximum gas you'll allow, protecting you from a runaway contract call. Your cost is roughly gas used × (base fee + priority fee), never exceeding your limit.
Because the base fee tracks demand, the same transaction can cost very different amounts hour to hour. Wallets estimate it for you, but when the network is congested, waiting for a quieter time — or using a Layer 2 (a later lesson) — can cut fees dramatically.
Ether units and reading the chain
Ether comes in units that trip up beginners. The base unit is the wei — the smallest, indivisible amount. Gwei is a billion wei, the convenient unit for expressing gas prices. Ether is 10^18 wei. Contracts and libraries almost always work in wei internally, so 1 ether is written as the integer 1000000000000000000; getting a units conversion wrong by a few zeros is a classic bug. You explore all of this — accounts, balances, transactions, contract code — through a block explorer like Etherscan, which presents the public world state in a readable form. Anyone can inspect any account or transaction, because the state is public.
- wei — the smallest unit; contracts compute in wei.
- gwei — a billion wei; used for gas prices.
- ether — 10^18 wei; the human-facing unit.
- block explorer (Etherscan) — read any account, transaction or contract.
That is the whole Ethereum model: a shared world computer, two kinds of account, transactions that change state in nonce order, gas that meters the work, and public state anyone can read. With this in hand, the next lesson introduces Solidity — the language you write the contract code in that lives at those contract accounts.