L04c-3 调用其他合约:new、地址强转、call 与 delegatecall
怎样拿到另一个合约来调用,低层调用的数据怎么编出来,以及 delegatecall 为什么改的是自己家的存储。
一句话版
拿到另一个合约有两条路:用 new 当场部署一份,或者把现成地址强转成合约类型。调用时用 call,对方在自己的存储上执行;用 delegatecall,对方的代码搬过来,在你自己的存储上执行。
上一页 L04c-2 的继承发生在编译期。这一页讲运行时合约之间怎么互相调用,这里没有编译器替你兜底。
先认识这几个词
| 词 | 白话意思 |
|---|---|
new |
在链上部署一个新合约并拿到它 |
| 地址强转 | 把一个地址当成某种合约类型来用 |
call |
低层调用:对方用对方自己的存储执行 |
delegatecall |
委托调用:借对方的代码,改的是我的存储 |
| 存储槽 storage slot | 合约永久数据按 0、1、2 编号的格子 |
abi.encodeWithSignature |
把函数签名和参数编成调用数据 |
一个类比:叫一支装修队
叫装修队,先要想这支队伍认不认识。熟人组的队,你知道他们会干什么;小广告叫来的队,报价单写着刷墙,进门之后干什么你管不了。这两种对应 new 和地址强转。
第二个分岔:你去他们店里干活,还是让他们进你家干活。前者用他们的材料改他们的墙,门卫登记的来访人是你。后者用你家的水电改你家的墙,门卫沿用上一层收到的来访身份。call 和 delegatecall 的差别就在这里。
类比在哪里失效:
- 换一支装修队不会挪你家的墙。
delegatecall换一份代码,却可能把承重墙当隔断拆掉,因为它按存储槽编号写,不认变量名。 - 现实里你能看着装修队干活,链上整串调用在同一笔交易里跑完,你只能事后看结果。
从零讲起
1. new 与地址强转
它解决什么问题
合约 A 想调合约 B 的函数,先得在代码里拿到一个 B 类型的对象。这个对象从哪来,决定了你对 B 的代码知道多少。
直觉
new B(args) 在链上真的部署一份 B,用的是你编译进去的代码,所以你知道它是什么。代价是部署要花 gas,写在构造器里会显著抬高部署成本。
B(addr) 什么都不部署,只是把一个已存在的地址当成 B 来用。之后的调用按 B 的 ABI 编码发出去,对方实际执行什么,由那个地址上的代码决定。
课件把风险收成一句总纲:虽然你多数时候预期打交道的是 EOA,但没有任何东西能阻止任意复杂、甚至恶意的合约调用你的代码,或被你的代码调用。
一步一步看
目标:对比用 new 部署和用地址强转拿到 Faucet 对象,看出两者发出的调用一样,区别只在目标地址上跑哪份代码。
-
同一作用域里要有 B 的定义,在另一个文件里就用
import引入。 -
部署新实例:
_faucet = new Faucet();,链上多出一个新地址。 -
使用现成实例:
_faucet = Faucet(payable(_f));,不部署,只套上 Faucet 的接口。 -
调用
_faucet.withdraw(0.1 ether),两种方式发出的调用数据完全一样。 -
区别只在目标地址上跑的是哪份代码。
怎么判断
看到 B(addr),问一句:这个地址是谁给的?是构造参数或函数参数传进来的,就要假设它可能是任何代码。看到 new B(),问的是另一句:B 的源码审过没有?知道代码不等于代码没有漏洞。
常见误解
「强转成 Faucet 类型,编译器就保证对方是 Faucet」对吗?
不对。编译器只检查转换语法和静态类型,不验证那个地址上的业务实现。恶意合约可以提供同名同参数的任意实现,或者让 fallback 接住所有调用。
「EIP-165 说它支持这个接口,就可以信它」对吗?
不对。supportsInterface 是对方自己回答的,恶意合约可以谎报。它只能用来识别接口,不能当安全认证。
试一下
在构造器里写 _faucet = new Faucet();,部署 Token 的这笔交易会发生什么?
Token 的创建交易里先执行构造器,构造器又部署了一份 Faucet,链上一次多出两个合约,gas 也按两份算。
2. call 与 delegatecall
它解决什么问题
有时不知道对方的类型,或者想自己控制调用数据和转账金额,就要用更低层的调用。还有一种需求更特别:想用存放在别处的代码,去操作自己合约的数据。前者靠 call,后者靠 delegatecall。
直觉
两者的代码都来自被调合约,差别只有一个:代码在谁的上下文里跑。call 让对方在对方自己的存储上执行,对方看到的 msg.sender 是调用方合约。delegatecall 把对方的代码搬到调用方的上下文里执行,存储、余额、address(this) 都是调用方的,msg.sender 和 msg.value 沿用调用方当前这一帧收到的值。
代理升级模式的全部原理就在这里:代理合约持有存储和地址,逻辑合约只提供代码,想升级就换一个逻辑合约地址。
一步一步看
目标:在 A 调 B、B 再调 C 的场景里对比 call 和 delegatecall,看出改的是谁的存储、msg.sender 是谁。
-
设定场景:用户 A 调合约 B,B 再去调合约 C。
-
B 用
call调 C:执行 C 的代码,改的是 C 的存储,C 看到的msg.sender是 B。 -
B 用
delegatecall调 C:执行 C 的代码,改的是 B 的存储,C 的代码看到的msg.sender是 A。 -
两种调用都返回
(bool success, bytes memory data),失败时被调帧回滚,B 自己不会自动回滚。 -
delegatecall按槽位编号写存储,C 的第 0 槽和 B 的第 0 槽必须是同一个意思。
| call | delegatecall | |
|---|---|---|
| 代码来自 | 合约 C | 合约 C |
| 执行上下文 / 存储 | 合约 C | 合约 B |
msg.sender |
合约 B | 用户 A |
msg.value |
本次调用传的值 | 保持原值 |
address(this) |
合约 C | 合约 B |
| 谁的状态被改 | 合约 C | 合约 B |
槽位对不上时会发生什么,看下面这张图:
怎么判断
遇到「谁的变量被改了」这类题,只问一句:代码在谁的上下文里跑?call 是被调方,delegatecall 是调用方。msg.sender 也跟着推:call 换成调用方合约,delegatecall 原样沿用。
常见误解
「delegatecall 里的 msg.sender 一定是 tx.origin」对吗?
不对。它沿用的是调用方当前这一帧的 sender。路径是 EOA → Router → Proxy → delegatecall 时,被调代码看到的是 Router。
「低层调用返回 true,业务就一定执行了」对吗?
不对。对没有代码的地址做 call 也可能返回 true;签名写错落到 fallback,同样返回 true。返回 false 时调用方也照样往下跑,要按业务决定用 require 回滚还是显式处理。
试一下
delegatecall 能不能写成 _addr.delegatecall{value: 1 ether}(...)?
不能。delegatecall 不接受 {value: ...},它继承当前帧的 msg.value,也不发生转账。call{value: ...} 的花括号语法是 0.6.2 引入的。
3. 调用数据怎么编
它解决什么问题
低层调用不知道对方的接口,只能直接按字节发调用数据。这串字节要自己编出来,编错一点,对方就认不出你要调哪个函数。
直觉
调用数据由两部分拼成:前 4 字节是函数选择器,后面是 ABI 编码的参数,每个参数补到 32 字节。选择器来自函数签名的 keccak256 哈希,签名的写法规则和事件 topic 是同一套:只写类型,不写参数名,不留空格。
编译器不会替你检查这串签名字符串。
一步一步看
目标:从签名字符串一路编到完整的调用数据,看出选择器怎么算出来,参数又怎样补齐拼在后面。
-
写签名字符串:
"f(uint256,address)",uint要写全成uint256。 -
求 keccak256,取前 4 字节,得到选择器。
-
把参数按 ABI 规则编码,每个参数补到 32 字节,拼在选择器后面。
-
这一整串就是
abi.encodeWithSignature("f(uint256,address)", _x, _addr)的返回值。 -
交给
target.call(data)或target.delegatecall(data)发出。
怎么判断
看到 abi.encodeWithSignature 里的字符串,逐字检查三件事:有没有参数名,有没有空格,类型是不是写全了。三处任一出错,哈希就变,选择器就匹配不上预期的函数。
常见误解
「签名多一个空格,编译器会报错」对吗?
不会。它只是一串字符串,编译器不检查。错的签名算出另一个选择器,对方匹配不上,有 fallback 就进 fallback,没有通常就 revert。
「函数选择器、事件 topic 和这里的签名是三套规则」对吗?
是同一套规则。区别只在取多少:选择器和这里都取哈希的前 4 字节,事件 topic[0] 取全部 32 字节。
试一下
签名写成 "foo(string _message,uint256 _x)" 会怎样?
带了参数名,哈希和正确签名不同,选择器匹配不上 foo,调用落到对方的 fallback 或者回滚。
把它们串起来
运行时调用别人的合约,要过两道关。第一道是拿到对象:new 让你知道实现来自哪里,地址强转则把信任交给传进来的那个地址。第二道是调用方式:高层调用和 call 让对方在自己家里干活,delegatecall 请对方进门,用你的存储和余额干活。
三件事最后都落到调用数据上。签名字符串编出选择器,选择器决定对方执行哪段代码,上下文决定这段代码改谁的存储。课件那句总纲在这里最锋利:被你调用的那份代码,可能是任意复杂、甚至恶意的代码。
课件里的坑
- [遗留未定义] 示例写
contract Token is mortal,而mortal在整份课件里从未定义过,前一页的同一段代码写的是is Owned(p.64、p.65) - [教学代码勿抄]
testCallFoo/testDelegatecallFoo只把(success, data)emit 出来,没有按业务处理失败(p.73) - [没讲风险] 课件只列了 call 和 delegatecall 的对照,没提存储布局必须兼容、不能对不可信地址做 delegatecall(p.69、p.70 + 补充)
- [没讲边界] 签名字符串多一个空格就换了选择器,编译器不会提醒,
success还可能是 true(p.71)
课后 10 分钟:考点复习
这 10 分钟怎么用:先把 call / delegatecall 那张六行表默出来,抓住「代码在谁的存储上跑」这一句,六行都能推回去;再默写调用数据的编码四步;最后把完整例题的两次调用在纸上各走一遍。
必背
- new 会在链上部署一个新合约并花 gas;地址强转不部署、也不验证目标的业务实现,必须确定那个实例确实是你假设的类型。
- call 与 delegatecall 的差别在于代码在谁的存储上执行:call 在被调合约自己的存储上跑、msg.sender 变成调用方合约;delegatecall 把被调合约的代码搬到调用方的存储上跑,msg.sender 与 msg.value 保持为调用方当前帧中的值——这是代理模式与可升级合约的基础。
- delegatecall 需要兼容的存储布局(槽位、偏移、类型);低层调用失败会回滚被调帧,但不自动让调用方回滚,须检查并处理 success。
- abi.encodeWithSignature 的签名只写类型、无参数名、无空格;多一个空格选择器就变,调用可能落到 fallback 而 success 仍为 true。
- 绝不能对不可信地址做 delegatecall:被调代码在调用方上下文里执行,能改调用方任何存储槽、动用调用方的余额。
课件例题
例 1(课件 p.72–73):call 和 delegatecall 的事件里各记了谁
题面:Receiver.foo(string memory _message, uint256 _x) 是 public payable,执行 emit Received(msg.sender, msg.value, _message) 后返回 _x + 1。Caller 的 testCallFoo 用 _addr.call{value: msg.value}(...),testDelegatecallFoo 用 _addr.delegatecall(...),调用数据都由 abi.encodeWithSignature("foo(string,uint256)", ..., 123) 生成。一个 EOA 直接调这两个函数,Received 事件里的 caller 各是谁?
提示
套用户 A、合约 B、合约 C 那张表:A 是 EOA,B 是 Caller,C 是 Receiver。
解答
call 版里 caller 是 Caller 合约地址,事件写在 Receiver 的日志里;delegatecall 版里 caller 是 EOA,事件从 Caller 的地址发出。返回值都是 123 + 1。逐步推导见下方完整例题。
完整例题
题面(课件 p.72–73):Receiver 的 foo(string memory _message, uint256 _x) 是 public payable,执行 emit Received(msg.sender, msg.value, _message) 后返回 _x + 1。Caller 有两个函数,都用 abi.encodeWithSignature("foo(string,uint256)", ..., 123) 生成调用数据:testCallFoo 用 _addr.call{value: msg.value}(...),testDelegatecallFoo 用 _addr.delegatecall(...),最后都 emit Response(success, data)。一个 EOA 直接调 testCallFoo(Receiver 地址) 并附带一些 ether,再调 testDelegatecallFoo(Receiver 地址)。问:两次调用中 Received 事件里的 caller 各是谁、事件出现在哪个合约的日志里、Response 的 data 解出来是多少、ether 最后在谁那里?
- 先算调用数据:签名
foo(string,uint256)只有类型、没有空格,选择器是 0x24ccab8f,后面跟两个参数的 ABI 编码。两次调用的选择器相同,只有字符串参数不同。 - call 版,代码和存储:
call让Receiver在自己的上下文里跑foo。这一层的直接调用者是Caller合约。 - call 版,事件:
Received的caller字段是Caller合约地址,amount是转过来的 ether 数,message是 “call foo from call”。事件写在Receiver的日志里,ether 也随{value: msg.value}进了Receiver。 - call 版,返回:
foo返回 123 + 1 = 124,经 ABI 编码放进data,success为 true,Caller再 emitResponse(true, data)。 - delegatecall 版,代码和存储:代码还是
Receiver.foo,执行上下文换成Caller自己。msg.sender和msg.value原样沿用Caller当前这一帧收到的值。 - delegatecall 版,事件:
Received的caller字段是 EOA,amount是 EOA 附带给testDelegatecallFoo的值,message是 “call foo from delegatecall”。事件从Caller的地址发出,尽管Caller源码里根本没声明Received。delegatecall不接受{value: ...},ether 一直留在Caller。 - delegatecall 版,返回:同样得到 123 + 1 = 124,
success为 true。 - 对照课件那张表:这两次正好是「用户 A 经合约 B 调合约 C」的两列,A 是 EOA、B 是
Caller、C 是Receiver。call 的 sender 是 B、改 C;delegatecall 的 sender 是 A、改 B。 - 为什么这例看不出危险:
foo只发事件、不写状态变量。它要是写了一个状态变量,delegatecall 时就会按槽位编号写进Caller的存储,而Caller根本没声明这个变量。
答题格式:每次调用写「代码来自谁 → 在谁的上下文 → msg.sender → 事件在谁的日志 → ether 在谁那里」。
变式题(先自己做)
改编自课件 p.72–73:(1) 有人把 testCallFoo 里的签名写成 "foo(string, uint256)",逗号后多了一个空格,其余不变。调用会怎样,success 是什么,Receiver 会 emit 哪条消息?(2) 给 Receiver 加一行状态变量 address public owner;,foo 里加一句 owner = msg.sender;;Caller 的第一个状态变量是 uint256 public counter;。EOA 调 testDelegatecallFoo 后,哪个合约的哪个变量被改了?
提示
第一问:空格会改变签名的哈希,选择器跟着变。想清楚 Receiver 拿到一个匹配不上的选择器时会走哪条路。第二问:delegatecall 按槽位编号写,不认变量名,先数一下 owner 和 counter 各在第几个槽。
判分点与答案(非官方评分标准)
判分点:① 第一问要答出「落到 fallback」和「success 仍为 true」两点;② 第二问要说出被改的是 Caller 的存储,并点名是哪个变量;③ 编译器不会检查签名字符串,别答成编译报错。
(1) 多一个空格,哈希完全不同,选择器匹配不上 foo。调用数据非空,于是走 Receiver 的 fallback。它是 payable 的,正常执行并 emit “Fallback was called”,success 仍是 true,data 为空。没人检查的话,这个错误就安静地过去了,fallback 里那条消息正好当调试探针。
(2) foo 的代码在 Caller 的上下文里执行,owner = msg.sender 写的是第 0 个槽。Receiver 第 0 槽是 owner,Caller 第 0 槽是 counter,于是 Caller.counter 被改写成 EOA 地址转成的整数,Receiver.owner 原封不动。这就是「存储布局必须兼容」的含义。
闪卡自测(含英文边界判断,非官方试题)
1. True or False: With delegatecall, msg.sender is always tx.origin.
中文:delegatecall 的发送者总是交易发起者。
False. It preserves the calling frame’s msg.sender, which may be a contract. 保留的是当前调用帧的 sender,不保证是 EOA。注意 always;Router → Proxy → Library 时,库里可以看到 Router(p.68–70 补充)。
2. 用 delegatecall 时最容易出的致命错误是什么?
存储布局不兼容(槽位、偏移、类型)。它按存储槽位编号写入,不按变量名:调用方第 0 槽是 owner、被调方第 0 槽是 value,一次「改 value」就把 owner 覆盖了(p.70)。
3. 调用其他合约的两种方式,各自的风险在哪?
new 部署已知代码,但不保证无漏洞;地址强转按给定 ABI 发调用,并不验证目标业务实现。两者都要核对代码与权限(p.64、p.65)。
4. 为什么绝不能对不可信地址做 delegatecall?
被调方代码在调用方的上下文里执行,等于拿到调用方的全部权限:能改任何一个存储槽、能动用调用方的余额(p.70)。
5. True or False: Every failed low-level call reverts the entire transaction.
中文:低层调用失败必回滚整笔交易。
False. The failed call frame reverts; the caller can handle the failure. 被调帧及子调用回滚,调用方收到 false 后可处理,也可用 require 传播失败。call failure 不等于 transaction failure(p.73)。
6. delegatecall 最常用在哪里?
调用库里的代码,以及代理升级模式:代码放在别处,让它操作自己合约的存储(p.68)。
下一讲
下一页 L04c-4 讲把控制权交出去之后最常见的事故:对方在你记账之前反手调回来,也就是重入攻击,再收尾到课件那七条最佳实践。
个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。