How Ethereum Works: The EVM and Smart Contracts

Ethereum in One Sentence

Ethereum is a decentralized virtual computer — a global state machine replicated across thousands of nodes, where state transitions are triggered by transactions and enforced by consensus.

The Account Model

Ethereum has two types of accounts:

Both account types store:

• balance — ETH in wei
• nonce — transaction counter (prevents replays)
• storageRoot — hash of contract's persistent storage
• codeHash — hash of bytecode (empty for EOAs)

The EVM (Ethereum Virtual Machine)

The EVM is a stack-based, 256-bit virtual machine. It processes opcodes that manipulate a stack, memory, and persistent storage.

// This Solidity...
uint256 x = 5 + 3;
 
// ...compiles to EVM opcodes:
PUSH1 0x05   // push 5 onto stack
PUSH1 0x03   // push 3 onto stack
ADD          // pop both, push result (8)

Storage vs Memory vs Stack

Gas: The Cost of Computation

Every EVM opcode costs gas. Gas has two purposes:

1. Compensate validators for computation
2. Prevent infinite loops (if you run out of gas, execution reverts)

// Gas-expensive: writing to storage (SSTORE = 20,000 gas)
mapping(address => uint256) public balances;
 
// Gas-cheap: reading from storage (SLOAD = 100 gas)
uint256 bal = balances[msg.sender];

Writing a Smart Contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
 
contract SimpleVault {
    mapping(address => uint256) private _balances;
 
    event Deposit(address indexed user, uint256 amount);
    event Withdraw(address indexed user, uint256 amount);
 
    function deposit() external payable {
        _balances[msg.sender] += msg.value;
        emit Deposit(msg.sender, msg.value);
    }
 
    function withdraw(uint256 amount) external {
        require(_balances[msg.sender] >= amount, "Insufficient balance");
        _balances[msg.sender] -= amount;
        // Checks-Effects-Interactions: update state BEFORE external call
        (bool ok, ) = msg.sender.call{value: amount}("");
        require(ok, "Transfer failed");
        emit Withdraw(msg.sender, amount);
    }
 
    function balanceOf(address user) external view returns (uint256) {
        return _balances[user];
    }
}

The Transaction Lifecycle

1. You sign a transaction with your private key
2. Broadcast it to the mempool
3. A validator picks it up and includes it in a block
4. The EVM executes the transaction, updating state
5. The new state root is committed to the chain

Consensus: Proof of Stake

Since the Merge (2022), Ethereum uses Proof of Stake:

• Validators stake 32 ETH as collateral
• They're randomly selected to propose and attest to blocks
• Dishonest behavior is penalized via slashing (losing staked ETH)

Conclusion

Ethereum's power comes from combining a global state machine, a Turing-complete VM, and crypto-economic incentives into a trustless execution environment. The EVM's gas model and account structure are the primitives everything else — DeFi, NFTs, DAOs — is built on.