EVM Visualizer
DocsCore Concepts

EVM Core Concepts

Understanding the key components and concepts of the Ethereum Virtual Machine (EVM) is essential for developing and debugging smart contracts.

What is the EVM?

The Ethereum Virtual Machine (EVM) is a Turing-complete, stack-based virtual machine that executes smart contract bytecode. It's the runtime environment for all smart contracts on the Ethereum blockchain and EVM-compatible chains.

The EVM is designed to be deterministic, meaning that given the same input and state, it will always produce the same output. This property is crucial for consensus across the network.

Transactions and Execution

Transactions are the fundamental unit of state change in Ethereum. When a transaction is submitted to the network, it triggers the execution of code in the EVM. There are two types of transactions:

  • Message Calls: Transactions that call functions on existing contracts.
  • Contract Creation: Transactions that deploy new contracts to the blockchain.

Execution Context

When a transaction is executed, the EVM creates an execution context that includes:

  • Code: The bytecode to be executed.
  • Program Counter (PC): Points to the current instruction in the bytecode.
  • Stack: A last-in, first-out data structure for operation arguments and results.
  • Memory: Volatile, byte-addressable memory for temporary storage.
  • Storage: Persistent key-value store for contract state.
  • Gas Remaining: The amount of gas available for execution.

Stack

The EVM is a stack-based machine, meaning that most operations take their arguments from the stack and push their results back onto it. The stack has a maximum depth of 1024 items, and each item is 256 bits (32 bytes) wide.

Common stack operations include:

  • PUSH1-32: Push a value onto the stack.
  • POP: Remove the top item from the stack.
  • DUP1-16: Duplicate a stack item.
  • SWAP1-16: Swap stack items.

Memory

Memory is a volatile, byte-addressable space that exists only during contract execution. It's used for temporary storage and is wiped after execution completes. Memory can be accessed in 32-byte chunks using MLOAD and MSTORE operations.

Memory expansion is not free—it costs gas. The cost increases quadratically as more memory is used, which encourages efficient memory usage.

Storage

Storage is persistent and remains after execution. It's a key-value store where both keys and values are 256 bits wide. Storage is expensive to use (in terms of gas) but necessary for maintaining state between transactions.

Storage operations include:

  • SLOAD: Load a value from storage.
  • SSTORE: Store a value in storage.

Gas and Execution Costs

Gas is a measure of computational effort in the EVM. Every operation consumes a specific amount of gas, and transactions must specify a gas limit—the maximum amount of gas they're willing to consume.

Gas serves two primary purposes:

  1. It prevents infinite loops and denial-of-service attacks.
  2. It compensates miners/validators for the computational resources they provide.

Gas costs vary by operation:

  • Basic operations (ADD, SUB, etc.): 3-5 gas
  • Memory operations (MLOAD, MSTORE): 3 gas + memory expansion cost
  • Storage operations (SLOAD, SSTORE): 200-20,000 gas, depending on the operation
  • External calls (CALL, DELEGATECALL): 100-700 gas + memory expansion cost

World State

The world state is a mapping between addresses and account states. Each account state includes:

  • Balance: The amount of Ether owned by the account.
  • Nonce: A counter used to ensure each transaction is processed only once.
  • Code Hash: The hash of the account's code (empty for EOAs).
  • Storage Root: The root hash of the account's storage trie.

There are two types of accounts in Ethereum:

  • Externally Owned Accounts (EOAs): Controlled by private keys, can initiate transactions.
  • Contract Accounts: Controlled by code, can only execute when called by an EOA or another contract.

Next Steps

Now that you understand the core concepts of the EVM, you can explore more advanced topics:

Previous: Getting StartedNext: Opcode Reference