T8 · Inside the EVM

A Real-World Problem

You write a batch distribution function. It accepts a list of addresses and amounts, updates each balance, then updates the cumulative total.

function airdrop(address[] memory to, uint256[] memory amounts) external {
    for (uint256 i = 0; i < to.length; i++) {
        balanceOf[to[i]] += amounts[i];
        totalDistributed += amounts[i];   // This line
    }
}

It works on the testnet. On mainnet launch day, operations passes in 200 addresses. The transaction exceeds the block limit and cannot be submitted.

You move the totalDistributed update outside the loop and change the parameters from memory to calldata. The logic stays the same, but the transaction now goes through at a much lower cost.

The same assignment can differ in cost by one or two orders of magnitude. This is not a compiler optimization failure. You are paying for different resources. This chapter asks what, exactly, you are paying for.

Thought Experiment

Imagine the EVM as a machine with only three kinds of space.

First: a permanent filing cabinet shared by the world. Put one page in it, and every node worldwide must keep a copy forever. Every node that joins later must download it too. The price buys “everyone on the network, forever.”

Second: a sheet of scratch paper. Write on it during execution and tear it up after the transaction. No one needs to retain it. It is cheap, but the price of a growing sheet is nonlinear: each expansion costs more than the last.

Third: a letter that has already arrived. The caller sends arguments with the transaction. Those bytes must travel with the transaction and be broadcast across the network anyway. You merely read them, allocating no extra space. It is the cheapest option, and it is read-only.

Now reconsider the opening code. totalDistributed += amounts[i] inside the loop writes to the filing cabinet on every iteration. Move it outside, and it writes once. A memory argument copies the whole letter onto scratch paper before use; calldata reads the letter directly.

The pricing logic is simple: pay according to whose resources you occupy and for how long. Remember that and you do not need to memorize the Gas differences below.

Now add a second thought experiment, which explains the rest of this chapter.

Suppose you have a script (another contract’s code) and perform it in your own house. The script says, “Replace what is in drawer 0 with X.” Whose drawer 0 does it mean?

Yours. The script belongs to someone else, but the house and drawer belong to you. Therefore, what drawer 0 is supposed to contain depends on the script writer’s assumptions, not your actual arrangement. They think drawer 0 contains the administrator’s name; you keep the safe key there. That is how the accident happens.

Your Decision

Return to the batch distribution function. If you can change only one thing, which do you change?

What Happens

All four options move data within the same table:

One conclusion deserves a sticky note on your monitor:

Gas is not a function of lines of code. It is a function of whose resources you occupy and for how long.

Several common questions then answer themselves. Why is reading a state variable much more expensive than reading a local variable? You must visit the filing cabinet. Why does clearing a value give a refund? You freed filing-cabinet space. Why does calling a view function offchain cost nothing? No one has to reach consensus on it. Why are loops over large arrays time bombs? Their cost grows with data, while the block limit stays fixed.

Build a Model

Three Spaces

A practical rule: default reference-type parameters of external functions to calldata; use memory only when you really need to modify them.

Storage Layout

State variables take 32-byte slots in declaration order. Consecutive small types that fit in one slot are packed together:

contract Layout {
    uint128 a;                        // Low 16 bytes of slot 0
    uint128 b;                        // High 16 bytes of slot 0; shares it with a
    uint256 c;                        // slot 1
    address owner;                    // Low 20 bytes of slot 2
    bool paused;                      // Slot 2, next to owner
    mapping(address => uint256) bal;  // Slot 3 is reserved, but holds no value itself
}

Mappings and dynamic arrays do not store their data in their own slot. Instead, that slot number participates in a hash calculation to locate each element. For a mapping(address => uint256), the value at key k is stored at keccak256(abi.encode(k, slotOfMapping)).

This has two practical uses: you can read anyone’s balance directly from the chain without a contract interface, and you can change any slot directly in a test. The latter is how the Fork tests in T12 can “give yourself money.”

Writes also have three price tiers: zero to nonzero is most expensive (new data every node must save forever); nonzero to another nonzero is much cheaper (no increase in data size); and nonzero to zero gives a partial refund (space is freed). Exact figures change with protocol upgrades, so do not memorize them. The three-tier structure is stable, and it explains why the first operation is often especially expensive.

Anatomy of a Call

An external call arrives as bytes. The first four are the function selector: the first four bytes of the hash of the function-signature string. Arguments follow, with each basic type padded to 32 bytes. Dynamic types (arrays, bytes, strings) put an offset first and append the contents later.

0xa9059cbb                                                          ← Selector, 4 bytes
  000000000000000000000000abcdef…0001                               ← First argument: address, left-padded to 32 bytes
  00000000000000000000000000000000000000000000000000000000000f4240  ← Second argument: amount

Three things follow:

1. A function is identified uniquely by its name plus argument types. Same name, different arguments means entirely different functions at the ABI level.
2. A selector has only four bytes, so collisions exist. This becomes a real trap in proxy contracts.
3. Calldata size directly costs money. Each additional 32 bytes of arguments adds a broadcast cost for users. On L2, it is often the largest part of the fee.

Delegatecall: Changing Whose Storage It Is

An ordinary call means “go to your house, run your code, change your storage.” delegatecall means “bring your code to my house and run it against my storage, while preserving msg.sender and msg.value.”

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

// The borrowed script
contract Logic {
    address public owner;                    // Logic thinks this is slot 0

    function setOwner(address a) external {
        owner = a;                           // Actually writes the caller's slot 0
    }
}

// Your own house
contract Proxy {
    address public implementation;           // slot 0  ← collides with Logic.owner
    address public admin;                    // slot 1

    constructor(address impl) {
        implementation = impl;
        admin = msg.sender;
    }

    fallback() external payable {
        // A real proxy must also forward return data unchanged, using inline assembly; omitted here
        (bool ok, ) = implementation.delegatecall(msg.data);
        require(ok, "delegatecall failed");
    }
}

If anyone calls Proxy using setOwner(0x…), the effect is to change implementation to the attacker’s address. On the next call, the whole proxy runs the attacker’s code.

This is the definition of delegatecall, not a bug in it. Code and storage have been separated, while the meaning of storage lives in the code. If the two sides disagree, the result is disastrous.

Three hard rules for proxies follow. T28 expands on each:

• Put the proxy’s own variables in slots that cannot collide with the logic contract. In practice, use fixed pseudorandom slots rather than declarations starting at slot 0.
• When upgrading logic, storage layout in the new version may only be appended at the end. Do not insert, change types, or reorder.
• A logic contract must never contain a callable self-destruction path or an initializer anyone can use.

What It Is Called

Hands-on

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract GasLab {
    uint256 public total;

    // A: write persistent storage on each loop iteration
    function sumA(uint256[] memory xs) external {
        for (uint256 i = 0; i < xs.length; i++) {
            total += xs[i];
        }
    }

    // B: use a local variable in the loop; write once at the end
    function sumB(uint256[] memory xs) external {
        uint256 acc = total;
        for (uint256 i = 0; i < xs.length; i++) {
            acc += xs[i];
        }
        total = acc;
    }

    // C: read directly from calldata instead of copying arguments to memory
    function sumC(uint256[] calldata xs) external {
        uint256 acc = total;
        for (uint256 i = 0; i < xs.length; i++) {
            acc += xs[i];
        }
        total = acc;
    }
}

AI Lab

Step one:
These two contracts are combined with delegatecall. For each storage slot, list what Proxy
thinks it contains and what Logic thinks it contains. Identify every mismatch.

Step two:
Using those mismatches, construct a concrete attack: which transactions does the attacker
send, in what order, and what do they gain? Describe actual function calls, not abstractions.

Step three:
Write a test that must fail against the current code and pass after it is fixed.

Real-World Case

Change One Variable

Takeaway Questions

Chapter Check