스토리지, 메모리, 스택

The EVM has several distinct places to keep data, each with different costs and lifetimes.

The three core data locations are the stack, memory, and storage. Choosing the right one is key to writing efficient contracts.

The stack is the EVM's scratchpad for computation. It holds up to 1024 values of 256 bits each.

Opcodes push and pop from the top of the stack. It is extremely cheap but tiny and temporary.

Memory is a temporary, linear byte array that exists only during a single transaction call.

It is used for things too big for the stack, like building a string or an array. It resets to empty when the call finishes.

Storage is the contract's permanent state, kept on the blockchain between transactions.

It is a key-value store mapping 256-bit slots to 256-bit values. State variables in a contract live here.

Cost rises sharply by location:

• Stack — cheapest, a few gas per op
• Memory — cheap, grows with size
• Storage — very expensive, especially first writes

Storage writes are costly because every node must persist them forever. A fresh storage write (SSTORE) can cost 20000 gas.

This is why developers minimize storage writes and prefer memory for temporary work.

Storage is organized into 32-byte slots. Smaller variables can be packed into one slot to save gas.

For example, two uint128 values fit together in a single 256-bit slot.

A fourth location, calldata, holds the read-only input data of a transaction or call.

It is the cheapest place to read function arguments and cannot be modified, making it ideal for inputs you only need to read.

Rules of thumb:

• Use the stack for short-lived computation
• Use memory for temporary structures
• Use storage only for data that must persist
• Use calldata for read-only inputs

Each location has a different lifetime:

• Stack and memory — die when the call ends
• Storage — persists permanently on-chain
• Calldata — exists for the duration of the call, read-only

The EVM separates data into stack, memory, storage, and calldata, ordered roughly from cheapest and shortest-lived to most expensive and permanent.

Smart developers keep persistent storage writes to a minimum.

You learned that:

• The stack is cheap, tiny, and temporary
• Memory is temporary scratch space for a call
• Storage is permanent but expensive
• Calldata is cheap, read-only input

Next: opcodes in detail.