L05a Proxy 与 delegatecall:招牌不换、后厨可换的那家店
合约代码改不了,就把数据留在 Proxy、把逻辑放进可替换的实现合约;从 delegatecall 讲到 fallback 转发和 EIP-1967。
一句话版
合约代码部署后改不了,那就把数据留在一个永远不变的地址,把逻辑放进另一份可以整份替换的合约。
先认识这几个词
| 词 | 全称 / 读法 | 一句人话 |
|---|---|---|
| 智能合约 | smart contract | 部署在区块链上的程序,部署后代码改不了 |
| gas | 燃料费 | 在以太坊上执行操作要付的手续费,操作越多越贵 |
| Proxy | 代理合约 | 用户一直访问的固定地址,保管全部数据 |
| Implementation | 实现合约 | 只放函数代码,可以换成新版本 |
| delegatecall | 委托调用 | 借别人的代码,在自己的数据上执行 |
| fallback | 兜底函数 | 调用的函数名找不到时,自动进入的那个函数 |
| slot | 存储槽 | 合约存数据的格子,每格 32 字节,从 0 开始编号 |
一个类比:招牌不换、后厨可换的那家店
顾客只认门口那块招牌,点单永远送到同一家店。这块招牌就是 Proxy 的地址。
后厨的菜谱可以整本换掉,菜谱就是实现合约。账本却必须留在店里,账本就是合约长期保存的数据。
真要换一家店,老顾客会找不到你。把账本搬过去,还要另付一大笔搬家费,也就是 gas。
菜单上没有的菜,交给万能接待口。接待口把点单原样递给后厨,再把回条原样送回顾客。这个接待口就是 fallback。
店长决定换哪本菜谱。新旧菜谱对「第几格抽屉放什么」必须一致,不然新厨师会把放招牌编号的抽屉当成计数器,一写就坏。
类比在哪里失效:
- 现实里换菜谱不影响抽屉编号。链上
delegatecall只认槽位编号,不认变量名。 - 现实里店长换菜谱只是内部的事。链上谁能换实现地址,是一个要单独回答的信任问题,下一页讲它的存储前提,再往后讲 DAO 治理。
从零讲起
1. 合约为什么改不了
它解决什么问题
先弄清楚问题本身:合约上线以后发现 bug,能不能直接改?这一节回答「能改什么、不能改什么」,后面所有设计都是为了绕开「代码不能改」这一条。
直觉
合约部署时,编译好的字节码(bytecode,机器能直接执行的指令)被写进区块链。区块链上已经写进去的东西不能改写,所以代码也跟着定死了。
这件事有两面。好处是安全,用户能事先读代码,知道合约会做什么。坏处是有 bug 也改不了,只能重新部署一份新合约。
一步一步看
目标:跟着一次发现 bug 后重新部署的过程,看出直接换新合约要付两笔代价:换地址和迁移数据。
-
你部署了合约,地址记作 A,里面已经存了很多用户的余额。
-
你发现一个 bug,想改代码。链上的字节码不能改写,这条路走不通。
-
你只好部署一份新合约,新地址记作 B。用户、前端、别的合约手里存的都还是 A。
-
你还得把 A 里的余额一条条搬到 B。每写一条都要花 gas,数据越多越贵。
情况 地址 数据 代价 原合约 A 全部用户余额 无 重新部署 B(新地址) 空的 要通知所有人换地址 迁移数据 B 逐条写入 大量 gas -
结论:直接部署新合约能修 bug,但要换地址、要付迁移费。Proxy 模式就是为了把这两个代价都去掉。
怎么判断
拿到一样东西,问它属于下面哪一类:
| 东西 | 能不能改 | 一句话 |
|---|---|---|
| 合约代码 | 不能 | 部署后不可变 |
| 状态变量 | 能 | 写进新值,旧的更新记录永久留在链上 |
| 所有权 | 能 | 可以转移 |
| 加新函数 | 不能 | 要重新部署或走 proxy |
| 交易历史 | 不能 | 永久在链上 |
| 升级 | 不是原生能力 | 只能靠 proxy patterns |
判断时盯住一点:「代码不变」和「状态在变」同时成立。余额天天在变,变的是数据;处理余额的那段逻辑始终是部署时那份。
常见误解
以为「链上一切都不能改」
链上的记录不能改写,但合约的状态可以更新。转账以后余额变了,这是新状态被写进去;旧状态和这次更新的记录都还留在链上。所以「写上链就不能改」要分开说:历史不能改,当前状态能变,代码不能变。
以为 selfdestruct 能把合约彻底删掉
EIP-6780 之后,合约如果不是在同一笔交易里创建的,自毁只转走余额,代码和存储都还在,之后照样能调用。只有同一笔交易里创建又自毁,才会真的删除。
试一下
一份合约部署后,Owner 想给它加一个 withdrawAll 函数。直接加行不行?有哪两条路?
不行,代码部署后不可变,加新函数也算改代码。两条路:一是重新部署一份带新函数的合约,代价是换地址、迁数据;二是一开始就用 proxy 模式,把新函数写进新的实现合约,再让 Proxy 指过去。
2. call 与 delegatecall
它解决什么问题
合约之间互相调用有两种方式。Proxy 要的效果很特别:代码来自别人,数据写在自己身上。只有 delegatecall 能做到,所以先把它和普通 call 分清楚。
从哪来(补充)
DELEGATECALL 这条指令来自 Vitalik Buterin 在 2015 年提出的 EIP-7。提案里写的动机之一,就是让合约可以更换它委托执行的代码地址,这正是后来 Proxy 升级的做法。另一个动机是把代码拆到多个合约里,绕开当时约 300 万 gas 的上限。
直觉
call 像是请别的店帮你做一道菜,菜在人家厨房做,人家的库存减少。
delegatecall 像是把别人的菜谱借过来,在你自己的厨房做,用的是你的库存。
一步一步看
目标:让 A 分别用 call 和 delegatecall 调 B 的同一个函数,看变量最后写进了谁的存储。
-
合约 A 用
call调合约 B 的函数。代码在 B 里跑,函数里写的变量是 B 的存储。 -
合约 A 改用
delegatecall调 B 的同一个函数。代码还是 B 的那份。 -
这一次,函数里写的变量落到 A 的存储上,B 的存储一格都没动。
-
按 EIP-7 的定义,
delegatecall还保留原调用方的msg.sender和转账金额,所以在 B 的代码看来,就像 A 自己在执行。 -
Proxy 用的是第 2 到第 4 步这种:Proxy 是 A,实现合约是 B。
怎么判断
遇到一次跨合约调用,先问两件事:
- 代码是谁的?两种调用都执行被调合约的代码。
- 写的是谁的存储?
call写被调方的,delegatecall写调用方的。
意思是:区分二者只看「数据落在哪」。题目问「用户余额存在哪个合约」时,先找调用链上哪一层用了 delegatecall,余额就在那一层的调用方身上。
常见误解
以为 delegatecall 会把实现合约的存储也同步改掉
不会。实现合约地址上的存储在走 Proxy 的路径里根本不会被写到。用户余额全在 Proxy 身上,实现合约只提供代码。
试一下
合约 A 用 delegatecall 调合约 B 的 setX(5),B 里 x 是第一个状态变量。调完之后,A 的 slot 0 和 B 的 slot 0 各是多少?(假设原来都是 0)
A 的 slot 0 变成 5,B 的 slot 0 还是 0。B 的代码按「第一个状态变量在 slot 0」去写,但它写的是调用方 A 的存储。
3. Proxy:把数据和逻辑拆开
它解决什么问题
它把第 1 节的两个代价一起去掉:用户永远找同一个地址,所以不用换地址;数据一直留在原地,所以不用迁移。
直觉
把一份合约拆成两份。一份叫 Proxy,只管保存数据,地址永远不变。另一份叫 Implementation,只放函数代码。
用户的交易永远发给 Proxy。Proxy 自己不处理业务,它记着一个「实现地址」,把调用转给那份代码去执行。升级时只改这个地址。
一步一步看
目标:从部署 v0 到换成 v1 走一遍 Proxy 升级,看出用户地址不变、数据不搬,跑的代码却已经换新。
-
部署实现合约 v0,再部署 Proxy,Proxy 里记下
impl_addr = v0。 -
用户把交易发给 Proxy 的地址。Proxy 用
delegatecall执行 v0 的代码,余额写在 Proxy 的存储上。 -
发现 v0 有 bug。部署修好的 v1,这一步不碰 Proxy,也不碰任何用户数据。
-
Owner 把 Proxy 里的
impl_addr改成 v1。 -
用户还是发给同一个地址。数据原地不动,执行的已经是 v1 的代码。
怎么判断
这个模式有两大好处:
- 可升级:升级时只把 Proxy 指向新的实现合约。
- 省 gas:多个只存数据的 Proxy 可以共用同一份逻辑,逻辑只部署一次。
它也带来一个新问题。课件那句原话是 No longer immutable, who can change the implementation address? 意思是:合约不再「不可变」了,那么谁有权改实现地址?技术上是 Owner;成熟协议会交给 DAO 投票加时间锁,本讲第三页专门讲。
常见误解
以为升级就是「改了合约代码」
没有任何一份代码被改写。v0 的字节码还在链上原封不动,v1 是另一份新部署的合约。变的只是 Proxy 存储里那个实现地址,它本来就是一个可以更新的状态变量。
以为 Proxy 让合约变得更安全
可升级也意味着有人能换掉逻辑。谁握着改地址的权力,谁就能把逻辑换成任何东西。用户要信任的对象从「这份代码」扩大到了「这份代码加上能改地址的人」。
试一下
三个 Proxy 共用同一个实现合约 v0。把其中一个 Proxy 的 impl_addr 改成 v1,另外两个会受影响吗?各自的数据呢?
不受影响。每个 Proxy 自己记实现地址、自己存数据;改的只是那一个 Proxy 的地址,另外两个仍然执行 v0,三份数据互不相干。
4. fallback:把任何调用原样转过去
它解决什么问题
用户调的是 increment()、transfer() 这类业务函数,Proxy 里根本没写这些函数。它需要一个入口接住所有未知调用,再原封不动地交给实现合约,并把结果原封不动地交回去。
直觉
Solidity 里,调用的函数名在合约里找不到时,会自动进入 fallback()。所以转发逻辑写在这里,Proxy 就不用事先声明实现合约的全部函数。
难点在返回值。普通 Solidity 函数必须声明返回类型,可 Proxy 事先不知道被调函数会返回什么。于是要用内联汇编(inline assembly,直接写底层指令),按字节原样搬运。
一步一步看
目标:按 fallback 里的五条汇编指令走一遍,看 Proxy 怎样把没写过的业务调用原样转给实现合约,再原样交回结果。
-
calldatacopy:把调用数据(calldata,函数选择器加参数)整段拷到内存。
-
delegatecall:用这段数据去调实现合约,代码在 Proxy 的存储上执行。
-
returndatacopy:执行完,把返回数据整段拷到内存。
-
switch result:看调用成功还是失败。
-
return / revert:成功就把返回数据原样交回调用者;失败就带着同样的数据回滚。
对应的代码:
fallback() external payable {
address _implementation = implementation;
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(gas(), _implementation, 0, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
怎么判断
逐个读懂 delegatecall 的六个参数,它的形状是 delegatecall(g, a, in, insize, out, outsize):
g是给这次调用的 gas,代码里写gas(),把剩下的都给它。a是实现合约地址。in, insize是输入数据在内存里的起点和长度,这里是从 0 起、calldatasize()那么长。out, outsize是预留放返回值的区域,这里写0, 0。
意思是:最后两个 0 表示先不预留输出区,因为事先不知道返回多长;调用结束后再用 returndatasize() 量出实际长度,用 returndatacopy 取回。delegatecall 成功返回 1,失败返回 0,所以 switch 里 case 0 走 revert。
常见误解
以为外部调用者对 Proxy 用的也是 delegatecall
外部合约对 Proxy 用的是普通 call。完整调用链是 Caller →(call)→ Proxy.fallback →(delegatecall)→ Implementation。真正的 delegatecall 只发生在 Proxy 内部。
以为用高级写法 addr.delegatecall(...) 就不需要汇编了
高级写法能拿到 bytes 形式的返回值,但 fallback 要把它原样当作自己的返回值交出去,普通 Solidity 函数做不到「返回任意类型」。所以要用汇编里的 return(p, s) 直接按字节返回。
试一下
实现合约里的函数执行到一半 revert 了。fallback 里哪一步决定 Proxy 也跟着回滚?回滚时带回的数据是什么?
switch result 那一步:delegatecall 失败返回 0,进入 case 0,执行 revert(0, returndatasize())。带回的是实现合约 revert 时给出的数据(比如错误信息),已经被 returndatacopy 拷到内存 0 起的位置。
5. 存储冲突与 EIP-1967
它解决什么问题
Proxy 和实现合约共用 Proxy 的同一片存储。Proxy 自己也要存一个变量,就是实现地址。如果它和实现合约的业务变量落在同一个槽,一写就互相覆盖。
从哪来(补充)
EIP-1967 由 Santiago Palladino、Francisco Giordano、Hadrien Croubois 在 2019 年提出,现为 Final 状态。它规定实现地址存在槽 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc,这个槽号由字符串 eip1967.proxy.implementation 的 keccak256 哈希减 1 得到。提案还提到一个动机:固定的槽位让区块浏览器这类工具能找到 Proxy 背后的实现合约。
直觉
存储槽按编号对号入座,不看变量名。Proxy 的代码说「slot 0 是实现地址」,实现合约的代码说「slot 0 是计数器」,两份代码都在同一片存储上跑,slot 0 就只有一格。
解决办法是把实现地址挪到一个极远的、伪随机的槽。业务变量从 slot 0 往后排,永远排不到那里。
一步一步看
目标:看实现合约的 count++ 怎样写坏 slot 0 里的实现地址,再看 EIP-1967 把地址挪到远处槽后两边为何不再相撞。
-
简单 Proxy 把
implementation声明为第一个状态变量,它在 slot 0。 -
实现合约的第一个状态变量是
uint256 count,按它自己的布局也在 slot 0。 -
用户调
increment()。代码在 Proxy 的存储上执行count++,改的是 slot 0。 -
slot 0 存的实现地址被加了 1,变成一个无关的地址。下一次调用就转发到错误的地方,整个代理废掉。
-
按 EIP-1967,实现地址放在由常量字符串算出来的远处槽,业务变量从 slot 0 照常排,两边不再相遇。
怎么判断
升级前过两条红线:
- 不能覆盖 Proxy 自己的变量,例如实现地址。
- 新实现必须兼容旧布局。旧版本 slot 0 放什么类型,新版本 slot 0 还得放同样的东西;新变量只能往后加。
意思是:实现合约换了,存储没换。新代码会按自己的声明顺序去解读那片旧存储,顺序一乱,读出来的就是别的变量的值。槽位怎么排,下一页从零讲。
常见误解
以为课件给了 EIP-1967 的具体槽号
课件只说「放到特殊槽、避免撞车」,没给槽号。上面那个槽号来自 EIP-1967 标准原文,答题时说清机制就够了。
以为只要变量名不同就不会冲突
存储只按槽号读写,变量名在编译后就不存在了。名字不同、槽号相同,照样是同一格。
试一下
v1 依次声明 uint256 a; uint256 b;。v2 想加一个 uint256 c,写成 uint256 c; uint256 a; uint256 b;。升级后读 a 会读到什么?应该怎么写?
v2 里 a 被挪到了 slot 1,而 slot 1 原来存的是 b,所以读 a 会读到旧的 b。正确写法是保持旧顺序,把新变量加在最后:uint256 a; uint256 b; uint256 c;。
把它们串起来
合约代码改不了,直接重新部署又要换地址、付迁移费。Proxy 模式把一份合约拆成两份:数据和地址留在 Proxy,代码放进可替换的实现合约。
把这两份接起来的是 delegatecall,它借实现合约的代码,在 Proxy 的存储上执行。Proxy 不知道用户会调什么函数,所以在 fallback 里用汇编原样搬运输入和输出。
两份合约共用一片存储,于是冒出撞槽的风险。EIP-1967 把实现地址挪到远处的特殊槽,升级时再守住「旧布局不动、新变量往后加」。要守住这条,得先会算每个变量落在哪个槽,这是下一页的内容。
课件里的坑
- [措辞不精确] p.22–23 把
delegatecall的 gas 参数写成 “gwei of gas”;实际参数是 gas 数量,答题按「提供 g 单位的 gas」理解即可(p.22–23) - [代码不完整] p.20–24 只给了 Proxy 和 Caller,没给 Implementation 的源码,
increment()实际返回什么无法从课件推出;这几页只用来认调用链(p.20–24) - [链下/链上混淆] p.67 写节点 “Compiles code from high-level language to bytecode”;编译通常由链下 solc 完成,链上 EVM 执行的是已部署的 bytecode(p.67)
- [朴素口径待修正] p.65 说部署后不能改,是教学用的朴素说法;p.72 总表用 Proxy 把「升级性 Not native」说完整——代码本身仍不可改,可变的是代理指向(p.65、p.72)
- [适用条件] p.72 Selfdestruct 一行 “Can deactivate but not erase”:EIP-6780 后,合约若非同一交易内创建,自毁只停止当前执行、转走余额,代码和 storage 都还在、之后仍可调用,谈不上停用;同一交易内创建又自毁才会删除(p.72)
课后 10 分钟:考点复习
这 10 分钟怎么用:合上页面,先画一遍 Owner、User、Proxy、实现合约四个框和箭头;再默写 fallback 五步,说清 delegatecall 最后两个 0 的意思;最后把不可变性总表七行按「能不能改」复述一遍。
必背
- Proxy 模式把状态变量存在 Proxy、函数逻辑存在 Implementation;用户交易永远打到 Proxy 地址,升级只需改实现地址;两大好处是可升级与多 Proxy 复用同一份逻辑省 gas,代价是谁能改 impl_addr 重新引入信任问题。
- delegatecall 在 Proxy 的存储上下文执行实现合约代码;转发写在 fallback,用 assembly 做 calldatacopy → delegatecall → returndatacopy → 按结果 return/revert;EIP-1967 把实现地址放特殊槽,避免与业务变量撞车;升级实现必须兼容旧状态变量布局。
- 不可变性总表:合约代码不可改、状态变量可更新、所有权可转移、selfdestruct 已弃用(EIP-6780 后,非同一交易内创建的合约自毁只转走余额、不删代码与存储)、加新函数与原生升级都不行——升级性 Not native,只能靠 proxy patterns。
- 直接部署新合约修 bug 有两个代价:新地址不等于旧地址,迁移旧状态要烧大量 gas。
- 调用链是 Caller →(call)→ Proxy.fallback →(delegatecall)→ Implementation;Caller 对 Proxy 用的是普通 call。
课件例题
例 1(课件 p.20–24):Caller 经 Proxy 调 increment 的调用链:见下方完整例题。
例 2(课件 p.71–72):合约到底能不能改
题面:p.71 问 “Anything written on the blockchain cannot be changed — True or false?” 结合 p.72 总表,逐项说明合约代码、状态变量、所有权、selfdestruct、加新函数、交易历史、升级性能不能改。
提示
先把「链上记录」和「合约当前状态」分开,再按总表七行逐个过。selfdestruct 那一行要想到 EIP-6780 之后的行为。
解答
- 这句话说得太满。链上记录本身不可改,但合约的状态可以更新。
- 合约代码:No,部署后不可变。状态变量:Yes,新状态被写入,旧的更新记录仍不可变地留在链上。所有权:Yes,可以转移。
- Selfdestruct:Deprecated。课件写 “Can deactivate but not erase”;EIP-6780 后,不在同一交易内创建的合约自毁只转走余额,代码和存储都还在。
- 加新函数:No,要重新部署或走 proxy。交易历史:No,永久留在链上。
- 升级性:Not native,只能靠 proxy patterns。
完整例题
题面(课件 p.20–24):课件给出最小 Proxy(构造时传入实现地址,存进状态变量 implementation)、p.21 的 fallback,以及下面的 Caller:
function increment() external returns(uint) {
(, bytes memory data) = proxy.call(abi.encodeWithSignature("increment()"));
return abi.decode(data, (uint));
}
问:(1) 写出从 Caller 到实现合约的完整调用链,每一跳用的是 call 还是 delegatecall?(2) increment() 改的计数器存在哪个合约?(3) Proxy 为什么能接住 increment() 这个它没声明的函数?(4) 如果实现合约的第一个状态变量是 uint256 count,会出什么事?
约定:实现合约源码课件没给,这里只按「increment 把一个计数器加一并返回」来理解调用链,不推返回的具体数值。
解法:
- 第一跳:Caller 对 Proxy 用普通
call,数据是increment()的函数选择器。 - 第二跳:Proxy 里没有
increment(),调用落进fallback;fallback 用delegatecall把同一段 calldata 交给implementation指向的合约。完整链条是 Caller →(call)→ Proxy.fallback →(delegatecall)→ Implementation。 - 数据在哪:
delegatecall在 Proxy 的存储上下文执行,计数器加一写在 Proxy 的存储上,实现合约自己的存储不变。 - 返回值怎么回来:fallback 用
returndatacopy把实现合约的返回数据拷进内存,再return原样交给 Caller;Caller 用abi.decode(data, (uint))解出数字。 - 撞槽:最小 Proxy 的
implementation在 slot 0。实现合约的count按它自己的布局也在 slot 0,count++实际改写的是 Proxy 的实现地址,下一次转发就指错了地方。这就是 p.17 的红线,也是 EIP-1967 要解决的事。
要点:两跳用的调用方式不同;数据永远落在用 delegatecall 的那一层的调用方,也就是 Proxy。
答题格式:先画出调用链并标出每跳的调用方式,再回答「存储在谁身上」,最后点出撞槽风险和 EIP-1967。
变式题
改编自课件 p.17:某 Proxy 用 EIP-1967 存实现地址。v1 依次声明 address owner; uint256 total;。v2 想加 bool paused,写成 bool paused; address owner; uint256 total;。(1) 升级到 v2 后,Proxy 的实现地址会被写坏吗?(2) v2 读 owner 会读到什么?(3) 怎么改?
提示
实现地址放在远处特殊槽,先排除第 (1) 问的风险。第 (2) 问只看业务变量从 slot 0 起怎么排:bool 1 字节、address 20 字节,能不能挤进同一槽?
判分点与答案(非官方评分标准)
判分点:① 说明实现地址不受影响及原因;② 写出 v1、v2 的槽位对比;③ 给出「新变量加在末尾」的改法。
(1) 不会。实现地址在 EIP-1967 的特殊槽,业务变量排不到那里 ✓。
(2) v1:slot 0 是 owner(20 字节,从最低位放),slot 1 是 total。v2:paused 1 字节和 owner 20 字节合计 21 字节,挤进 slot 0,paused 在最低字节,owner 紧挨着往左放。v2 读 owner 时,取的是 slot 0 的第 2 到第 21 个字节,而旧数据里地址占的是第 1 到第 20 个字节,读出来是一个错位的地址;paused 读到的是旧地址的最低字节 ✓。
(3) 保持旧顺序,把新变量加在最后:address owner; uint256 total; bool paused; ✓。
闪卡自测
1. Proxy 模式里 state 和 function 分别在哪?用户交易的 to 是谁?
state 在 Proxy,function 在 Implementation;用户永远打 Proxy 地址(p.4–5)。
2. True or False: With a proxy, the implementation contract stores all user balances.
中文:有了代理,用户余额存在实现合约里。
False. Balances live in the proxy’s storage; the implementation only provides code.(p.4、p.16)
3. 为什么转发要写在 fallback?为什么需要 assembly?
Proxy 不必事先声明实现的全部函数;返回类型事先未知,要用 calldatacopy / returndatacopy 按实际长度动态 return 或 revert(p.18–19)。
4. delegatecall(gas(), impl, 0, calldatasize(), 0, 0) 最后两个 0 是什么意思?
不预留输出区;返回值稍后用 returndatasize() 量长度、returndatacopy 取回(p.21–23)。
5. EIP-1967 解决什么问题?
把实现地址等代理专有变量放到特殊伪随机槽,避免与实现合约业务变量撞槽(p.25)。
6. 用一句话:智能合约原生支持升级吗?
不支持。升级性 Not native,只能靠 proxy patterns(p.72)。
7. True or False: After EIP-6780, SELFDESTRUCT on an existing contract deletes its code and storage.
中文:EIP-6780 之后,对已存在的合约 selfdestruct 会删掉代码和存储。
False (unless the contract was created in the same transaction). 它只停止当前执行、转走余额,代码和存储都留着(p.72)。
下一讲
L05b 存储布局:Proxy 能不能安全升级,取决于你能不能算清每个变量落在哪个槽。下一页从一个槽的 32 个字节讲起,一路算到动态数组和 mapping。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。