T8 · EVM 深入

一个现实问题

你写了一个批量发放的函数：传进来一组地址和一组数量，挨个记账，最后更新一个累计总额。

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];   // 这一行
    }
}

测试网上跑得好好的。上主网那天，运营传了 200 个地址进去，交易直接超出区块上限，发不出去。

你把 totalDistributed 改成循环外面加一次，参数从 memory 改成 calldata，逻辑一个字没动，交易就过去了，而且费用掉了一大截。

同样一行赋值，代价可以差出一两个数量级。这不是编译器优化不够，是你在为不同的资源付费。这一章要搞清楚的就是：你到底在为什么付钱。

思想实验

把 EVM 想成一台只有三种储物空间的机器。

第一种：一个全球共享的永久档案柜。 你往里放一页纸，全世界每一个节点都要永远保存这一页的副本，未来每一个新同步的节点也要下载它。你交的那笔钱，买的是「全网所有人，永远」。

第二种：一张草稿纸。 执行期间随便写，交易结束就撕掉，没有人需要长期保存。便宜，但纸张变大时价格不是线性涨的——纸越大，扩纸的边际成本越高。

第三种：一封已经寄到的信。 调用者把参数随交易一起发过来，这些字节本来就得跟着交易走、本来就要被全网传播。你只是读它，不需要额外分配任何空间。最便宜，而且只读。

现在回看开头那段代码：totalDistributed += amounts[i] 放在循环里，意味着每一轮都往档案柜写一次；挪到循环外，就只写一次。memory 参数意味着把整封信原样抄到草稿纸上再用，calldata 意味着直接读信。

定价逻辑其实非常朴素：你占用了谁的资源、占用多久，就付多少钱。 记住这一句，下面所有的 Gas 差异都不需要背。

再加第二个思想实验，它是这一章后半段的全部内容。

假设你手上有一个剧本（另一份合约的代码），你在自己家里照着它演。剧本里写着「把第 0 号抽屉里的东西换成 X」。问题是，第 0 号抽屉指的是谁家的抽屉？

答案是：你家的。剧本是别人的，房子是你的，抽屉也是你的。于是**「第 0 号抽屉里装的是什么」这件事，由剧本作者的想象决定，而不是由你的实际摆放决定**。他以为第 0 号放的是管理员名字，你实际放的是保险柜钥匙，事故就这么发生了。

你来决定

回到那个批量发放函数。只能改一处，你改哪一处？

观察结果

四个选项都在同一张表上移动：

一条结论，值得写在便签上贴显示器：

Gas 不是代码行数的函数，是「你占用了谁的资源多久」的函数。

顺着这句话，几个经常被问到的现象立刻就有答案了：为什么读一个状态变量比读一个局部变量贵得多（要去摸档案柜）；为什么把一个值清零会退钱（你腾出了档案柜的空间）；为什么 view 函数在链下调用不花钱（没有人需要为它达成共识）；为什么大数组的循环是定时炸弹（成本随数据增长，而区块上限是固定的）。

建立模型

三块空间

一条实用规则：外部函数的引用类型参数默认写 calldata，只有在真的需要修改它时才退回 memory。

存储的布局

状态变量按声明顺序占用 32 字节一个的槽，能塞进同一个槽的连续小类型会被打包：

contract Layout {
    uint128 a;                        // slot 0 的低 16 字节
    uint128 b;                        // slot 0 的高 16 字节，和 a 共用
    uint256 c;                        // slot 1
    address owner;                    // slot 2 的低 20 字节
    bool paused;                      // slot 2，紧挨着 owner
    mapping(address => uint256) bal;  // slot 3 被「占位」，但槽里不存东西
}

映射和动态数组不把数据放在自己的槽里，而是用那个槽号参与哈希计算，算出每个元素的真实位置。对于 mapping(address => uint256)，键 k 的值放在 keccak256(abi.encode(k, slotOfMapping)) 这个位置。

知道这件事有两个实际用处：你能直接从链上读出任意一个人的余额，不需要合约提供接口；以及你能在测试里直接改写任意槽，这是 T12 的 Fork 测试能「给自己发钱」的原理。

写入还分三档价格：从零写成非零最贵（新增一份全网要永久保存的数据），非零改非零便宜不少（数据量没变），非零写回零会退一部分（腾出了空间）。具体数值会随协议升级变化，不要背，但这个三档结构很稳定，它解释了为什么「第一次操作总是特别贵」。

一次调用长什么样

外部调用的输入就是一段字节：前 4 个字节是函数选择器，等于函数签名字符串哈希后的前四字节；后面是参数，每个基础类型都补齐到 32 字节；动态类型（数组、bytes、string）先放一个偏移量，内容拼在后面。

0xa9059cbb                                                          ← 选择器，4 字节
  000000000000000000000000abcdef…0001                               ← 第一个参数：地址，左补零到 32 字节
  00000000000000000000000000000000000000000000000000000000000f4240  ← 第二个参数：数量

三件事因此成立：

1. 函数名加参数类型才唯一确定一个函数。 同名不同参在 ABI 层面是两个完全不同的函数。
2. 选择器只有 4 字节，会碰撞。 这个事实在代理合约里会变成一个真实的坑。
3. calldata 的体积直接是钱。 参数里每多一个 32 字节，用户就多付一份传播成本。在 L2 上这一项往往是费用的大头。

Delegatecall：改写「这是谁的存储」

普通调用是「去你家，用你的代码，动你的存储」。delegatecall 是「把你的代码搬到我家来跑，动的是我的存储，而且 msg.sender 和 msg.value 保持不变」。

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

// 被借用的剧本
contract Logic {
    address public owner;                    // 它以为自己是 slot 0

    function setOwner(address a) external {
        owner = a;                           // 实际上写的是「调用者的 slot 0」
    }
}

// 自己的房子
contract Proxy {
    address public implementation;           // slot 0  ← 和 Logic 的 owner 撞在一起
    address public admin;                    // slot 1

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

    fallback() external payable {
        // 真正的代理还要把返回数据原样转发回去，那一步需要内联汇编，这里省略
        (bool ok, ) = implementation.delegatecall(msg.data);
        require(ok, "delegatecall failed");
    }
}

任何人对 Proxy 调用 setOwner(0x…)，落地的效果是把 implementation 改成了攻击者给的地址。下一次调用，整个代理就跑攻击者的代码了。

这不是 bug，是 delegatecall 的定义。 代码和存储被拆开了，而存储的含义写在代码里。两边对不上，就是灾难。

由此推出代理模式的三条铁律，T28 会展开每一条：

• 代理自己的变量必须放在不会和逻辑合约冲突的位置，实践中是放在伪随机的固定槽里，而不是从 slot 0 开始声明。
• 升级逻辑合约时，新版本的存储布局只能在尾部追加，不能插入、不能改类型、不能调顺序。
• 逻辑合约里绝对不能有能把自己销毁的指令，也不能有能让任意人初始化的函数。

它叫什么

动手

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

contract GasLab {
    uint256 public total;

    // A：每一轮循环都写一次持久存储
    function sumA(uint256[] memory xs) external {
        for (uint256 i = 0; i < xs.length; i++) {
            total += xs[i];
        }
    }

    // B：循环内只用局部变量，结束后写一次
    function sumB(uint256[] memory xs) external {
        uint256 acc = total;
        for (uint256 i = 0; i < xs.length; i++) {
            acc += xs[i];
        }
        total = acc;
    }

    // C：参数不拷贝到内存，直接从调用数据读
    function sumC(uint256[] calldata xs) external {
        uint256 acc = total;
        for (uint256 i = 0; i < xs.length; i++) {
            acc += xs[i];
        }
        total = acc;
    }
}

AI Lab

第一步：
这两份合约通过 delegatecall 组合在一起。请逐个存储槽列出：
Proxy 认为每个槽存的是什么，Logic 认为每个槽存的是什么。指出所有不一致的位置。

第二步：
基于这些不一致，构造一个具体的攻击：攻击者发什么交易、按什么顺序、
最终获得什么。用实际的函数调用描述，不要用抽象的说法。

第三步：
写一个测试，它在当前代码上必须失败，在修好之后必须通过。

真实案例

改一个变量

带走的问题

本章自测