← COMP5565 全部讲次
L04c-3 · 第 4 周

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 对象,看出两者发出的调用一样,区别只在目标地址上跑哪份代码。

  1. 同一作用域里要有 B 的定义,在另一个文件里就用 import 引入。

  2. 部署新实例:_faucet = new Faucet();,链上多出一个新地址。

  3. 使用现成实例:_faucet = Faucet(payable(_f));,不部署,只套上 Faucet 的接口。

  4. 调用 _faucet.withdraw(0.1 ether),两种方式发出的调用数据完全一样。

  5. 区别只在目标地址上跑的是哪份代码。

    两种拿到合约的方式并排:左边 new 会部署新合约并得到新地址,右边地址强转不部署、只相信这个地址真的是 B,右边一列被青绿高亮表示风险所在

怎么判断

看到 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 是谁。

  1. 设定场景:用户 A 调合约 B,B 再去调合约 C。

  2. B 用 call 调 C:执行 C 的代码,改的是 C 的存储,C 看到的 msg.sender 是 B。

  3. B 用 delegatecall 调 C:执行 C 的代码,改的是 B 的存储,C 的代码看到的 msg.sender 是 A。

  4. 两种调用都返回 (bool success, bytes memory data),失败时被调帧回滚,B 自己不会自动回滚。

  5. delegatecall 按槽位编号写存储,C 的第 0 槽和 B 的第 0 槽必须是同一个意思。

    call 与 delegatecall 对比图:call 在 Lib 的存储上执行,msg.sender 是 Caller;delegatecall 在 Caller 的存储上执行,保留 Caller 当前帧的 sender 和 value,存储须按槽位、偏移和类型兼容

call delegatecall
代码来自 合约 C 合约 C
执行上下文 / 存储 合约 C 合约 B
msg.sender 合约 B 用户 A
msg.value 本次调用传的值 保持原值
address(this) 合约 C 合约 B
谁的状态被改 合约 C 合约 B

槽位对不上时会发生什么,看下面这张图:

存储槽冲突示意表:slot 0 在 Proxy 里是 address owner,在 Lib 里是 uint counter 并被青绿高亮,Lib 的代码经 delegatecall 写 counter 时,实际覆盖了 Proxy 的 owner

怎么判断

遇到「谁的变量被改了」这类题,只问一句:代码在谁的上下文里跑?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 是同一套:只写类型,不写参数名,不留空格。

编译器不会替你检查这串签名字符串。

一步一步看

目标:从签名字符串一路编到完整的调用数据,看出选择器怎么算出来,参数又怎样补齐拼在后面。

  1. 写签名字符串:"f(uint256,address)",uint 要写全成 uint256。

  2. 求 keccak256,取前 4 字节,得到选择器。

  3. 把参数按 ABI 规则编码,每个参数补到 32 字节,拼在选择器后面。

  4. 这一整串就是 abi.encodeWithSignature("f(uint256,address)", _x, _addr) 的返回值。

  5. 交给 target.call(data) 或 target.delegatecall(data) 发出。

    调用数据编码流程:签名字符串 f(uint256,address) 经过被青绿高亮的 keccak256 取前 4 字节得到选择器,再拼上每个补到 32 字节的参数,组成完整的调用数据

怎么判断

看到 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 那张六行表默出来,抓住「代码在谁的存储上跑」这一句,六行都能推回去;再默写调用数据的编码四步;最后把完整例题的两次调用在纸上各走一遍。

必背

  1. new 会在链上部署一个新合约并花 gas;地址强转不部署、也不验证目标的业务实现,必须确定那个实例确实是你假设的类型。
  2. call 与 delegatecall 的差别在于代码在谁的存储上执行:call 在被调合约自己的存储上跑、msg.sender 变成调用方合约;delegatecall 把被调合约的代码搬到调用方的存储上跑,msg.sender 与 msg.value 保持为调用方当前帧中的值——这是代理模式与可升级合约的基础。
  3. delegatecall 需要兼容的存储布局(槽位、偏移、类型);低层调用失败会回滚被调帧,但不自动让调用方回滚,须检查并处理 success。
  4. abi.encodeWithSignature 的签名只写类型、无参数名、无空格;多一个空格选择器就变,调用可能落到 fallback 而 success 仍为 true。
  5. 绝不能对不可信地址做 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 最后在谁那里?

  1. 先算调用数据:签名 foo(string,uint256) 只有类型、没有空格,选择器是 0x24ccab8f,后面跟两个参数的 ABI 编码。两次调用的选择器相同,只有字符串参数不同。
  2. call 版,代码和存储:call 让 Receiver 在自己的上下文里跑 foo。这一层的直接调用者是 Caller 合约。
  3. call 版,事件:Received 的 caller 字段是 Caller 合约地址,amount 是转过来的 ether 数,message 是 “call foo from call”。事件写在 Receiver 的日志里,ether 也随 {value: msg.value} 进了 Receiver。
  4. call 版,返回:foo 返回 123 + 1 = 124,经 ABI 编码放进 data,success 为 true,Caller 再 emit Response(true, data)。
  5. delegatecall 版,代码和存储:代码还是 Receiver.foo,执行上下文换成 Caller 自己。msg.sender 和 msg.value 原样沿用 Caller 当前这一帧收到的值。
  6. delegatecall 版,事件:Received 的 caller 字段是 EOA,amount 是 EOA 附带给 testDelegatecallFoo 的值,message 是 “call foo from delegatecall”。事件从 Caller 的地址发出,尽管 Caller 源码里根本没声明 Received。delegatecall 不接受 {value: ...},ether 一直留在 Caller。
  7. delegatecall 版,返回:同样得到 123 + 1 = 124,success 为 true。
  8. 对照课件那张表:这两次正好是「用户 A 经合约 B 调合约 C」的两列,A 是 EOA、B 是 Caller、C 是 Receiver。call 的 sender 是 B、改 C;delegatecall 的 sender 是 A、改 B。
  9. 为什么这例看不出危险: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 讲把控制权交出去之后最常见的事故:对方在你记账之前反手调回来,也就是重入攻击,再收尾到课件那七条最佳实践。

下一讲 →
L04c-4 L04c-4 重入攻击、CEI 与七条最佳实践

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。