15.3.3 ABI 编码与调用栈
所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.3 以太坊与 EVM
本节要解决的问题
面试里问 ABI,多数人答"就是函数签名"。这是入门。真正的分水岭是:能不能说清 selector 是 keccak256 签名前 4 字节、动态类型的 offset 机制、fallback 与 receive 的区别,以及 DELEGATECALL 调用栈里 msg.sender 为什么不变。本节解决四个具体问题:一是分清 ABI 编码的静态类型与动态类型规则(32 字节对齐、offset 指向);二是讲清 fallback 与 receive 的触发条件差异(receive 只收 ETH,fallback 收未知函数);三是把 selector 碰撞(4 字节只有 40 亿种,碰撞概率不低)与错误处理(Error(string)、Panic(uint32))串起来;四是说明低级 call/staticcall 的返回值判断与 try/catch 的编译期展开。
学习目标
学完本节,你应当能够:
- 手算一个函数签名的 selector(keccak256 前 4 字节),并写出 ABI 编码的静态类型与动态类型布局。
- 区分 fallback 与 receive 的触发条件,并说明什么时候用哪个。
- 解释 DELEGATECALL 调用栈里 msg.sender、address(this)、storage 归属为什么不变。
- 写出低级 call 的正确错误处理(检查 ok、检查返回值长度、revert with data)。
先修与前置
- 建议先读 15.3.1 EVM 架构与执行模型 的四区模型与四种调用指令。
- 本节是 15.3.4 状态树、收据与事件日志 的前置,先懂 ABI 再看事件日志。
知识地图
ABI 编码:
函数选择器 = keccak256("transfer(address,uint256)")[:4]
静态类型(uint/address/bool):直接编码,32 字节对齐
动态类型(string/bytes/array):offset 指向 + 数据段
调用数据布局:
[selector(4 字节)][参数 1(32 字节)][参数 2(32 字节)]...
动态类型:offset 指向数据段起始位置
fallback vs receive:
receive():只收 ETH(data 为空),msg.data 为空
fallback():收未知函数调用(selector 不匹配),或收 ETH + data 非空
错误处理:
revert("...") → Error(string) selector
require(cond, "...") → 同上
assert(cond) → Panic(uint32)
自定义 error → 自定义 selector
DELEGATECALL 调用栈:
EOA → Proxy → Impl
address(this) = Proxy(不变)
msg.sender = EOA(不变)
storage = Proxy 的槽位(不变)
核心术语
- ABI(Application Binary Interface):合约与外部交互的二进制编码规范,规定函数选择器、参数编码、返回值编码。
- selector(函数选择器):keccak256(函数签名) 前 4 字节,用于识别调用的函数。
- fallback:合约没有匹配函数时触发的兜底函数,可 payable。
- receive:只在收 ETH 且 data 为空时触发,是 fallback 的特例。
- 动态类型:string、bytes、动态数组,编码时用 offset 指向数据段。
- Error(string):Solidity 0.4.22+ 的 revert 错误格式,selector 是 keccak256("Error(string)")[:4]。
- Panic(uint32):assert 失败的错误格式,selector 是 keccak256("Panic(uint256)")[:4]。
- try/catch:Solidity 0.6+ 的外部调用错误处理,把低级 call 的返回值判断编译成高级语法。
覆盖范围
- 函数选择器的计算与碰撞概率
- ABI 编码规则:静态类型、动态类型 offset、数组嵌套
- fallback 与 receive 的触发条件与差异
- 错误编码:Error(string)、Panic(uint32)、自定义 error
- 事件 ABI 与 topic 0 的关系
- DELEGATECALL 调用栈上下文保持
- 低级 call/staticcall 的返回值判断与 try/catch 展开
- CREATE2 的盐地址预测与 clash 防护
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 15.3.3-001 | 函数选择器是怎么算出来的? | 基础 | ★★★★★ |
| 15.3.3-002 | ABI 编码里动态类型的 offset 是什么? | 基础 | ★★★★ |
| 15.3.3-003 | fallback 和 receive 有什么区别? | 基础 | ★★★★★ |
| 15.3.3-004 | selector 碰撞是什么?概率有多高? | 进阶 | ★★★★ |
| 15.3.3-005 | calldata 为什么是只读的?数组切片怎么用? | 进阶 | ★★★ |
| 15.3.3-006 | Error(string) 和 Panic(uint32) 有什么区别? | 进阶 | ★★★★ |
| 15.3.3-007 | 事件的 topic 0 是什么?与 selector 有什么关系? | 进阶 | ★★★★ |
| 15.3.3-008 | DELEGATECALL 调用栈里 msg.sender 是谁? | 高级 | ★★★★★ |
| 15.3.3-009 | 低级 call 失败时怎么正确处理? | 高级 | ★★★★ |
| 15.3.3-010 | CREATE2 盐地址怎么预测?怎么防 clash? | 高级 | ★★★ |
15.3.3-001 函数选择器是怎么算出来的?
一句话结论
函数选择器 = keccak256(函数签名) 的前 4 字节,函数签名是"函数名(参数类型1,参数类型2,...)",不带空格。例如 transfer(address,uint256) 的 selector 是 keccak256("transfer(address,uint256)") 前 4 字节 = 0xa9059cbb。
概念解释
- 函数签名:函数名 + 参数类型列表,不带空格,如
transfer(address,uint256)。 - keccak256:以太坊用的哈希函数(不是 SHA3),输出 32 字节。
- selector:取前 4 字节(8 个 hex 字符),用于识别调用的函数。
- 碰撞:4 字节只有约 40 亿种,不同函数可能算出相同 selector。
原理流程
- 写出函数签名:
transfer(address,uint256)(注意:参数类型不带变量名,不带空格)。 - 对签名做 keccak256 哈希,得到 32 字节。
- 取前 4 字节,就是 selector。
- 调用时 calldata 前 4 字节是 selector,后面是参数编码。
- 合约收到调用时,用 selector 匹配函数。
代码或图示
计算 selector:
函数:transfer(address to, uint256 amount)
签名:transfer(address,uint256)
keccak256("transfer(address,uint256)") = 0xa9059cbb2ab09eb219583f1f5a...
前 4 字节 = 0xa9059cbb
调用数据布局:
[a9059cbb][to(32 字节)][amount(32 字节)]
selector
常用 selector:
transfer(address,uint256) = 0xa9059cbb
approve(address,uint256) = 0x095ea7b3
balanceOf(address) = 0x70a08231
transferFrom(address,address,uint256) = 0x23b872dd
常见误区
- 误区:selector 是函数名的哈希;正解:是函数签名(含参数类型)的哈希,同名不同参数的函数 selector 不同。
- 误区:用 SHA3 而不是 keccak256;正解:以太坊用的是 keccak256,不是 NIST 的 SHA3(虽然算法相同,但 padding 不同)。
- 误区:selector 是 32 字节;正解:只有前 4 字节,calldata 前 4 字节就是 selector。
追问
- 为什么 selector 只有 4 字节?答:为了让 calldata 紧凑;4 字节约 40 亿种,足够区分常用函数。机制上 4 字节是工程上的取舍——再长浪费 calldata,再短碰撞太多。边界在于:碰撞概率随合约数量增长而上升。延伸:这就是为什么会有 selector 碰撞攻击。
- 为什么不带参数名?答:因为 ABI 编码只关心类型,不关心参数名;两个函数
transfer(address to, uint256 amount)与transfer(address recipient, uint256 value)的 selector 相同。机制上参数名只是 Solidity 语法糖,不影响 ABI。边界在于:这也是为什么重载函数(同名不同参数)在 ABI 层面是不同函数。延伸:Solidity 的函数重载是编译期特性。 - keccak256 与 SHA3 有什么区别?答:算法本身相同,但 padding 不同;以太坊的 keccak256 用的是原始 Keccak padding,NIST 标准化的 SHA3 用了不同的 padding。机制上两者输出不同。边界在于:JavaScript 里要用
ethereumjs-util的 keccak256,而不是 Node 的 crypto.sha3。延伸:这是以太坊早期选择的历史原因。
15.3.3-002 ABI 编码里动态类型的 offset 是什么?
一句话结论
ABI 编码里,动态类型(string、bytes、动态数组)不直接放在参数位置,而是放一个 offset(32 字节)指向数据段的起始位置;数据段在所有参数之后,按顺序排列。这样静态类型参数紧凑在前,动态数据集中在后。
概念解释
- 静态类型:uint、int、address、bool、定长数组,直接编码,每个 32 字节。
- 动态类型:string、bytes、动态数组,编码时先放 offset(32 字节),数据段在后面。
- offset:从 calldata 起始位置到数据段的字节偏移量(通常 32 的倍数)。
- 嵌套:动态数组里套动态类型时,offset 是相对位置。
原理流程
- 调用
f(uint a, string calldata b):a 是静态类型,b 是动态类型。 - 编码布局:[selector][a(32 字节)][offset_to_b(32 字节)][b 的数据]。
- offset_to_b 指向 b 数据段的起始位置(从 calldata 开始算字节数)。
- b 的数据段:先放长度(32 字节),再放内容(padding 到 32 字节倍数)。
- 多个动态参数时,offset 依次指向各自的数据段。
代码或图示
调用 f(uint a, string b):
a = 42
b = "hello"
编码布局(字节偏移):
0x00-0x03: selector
0x04-0x23: a = 42(32 字节,静态类型)
0x24-0x43: offset_to_b = 0x40(十进制 64,指向 b 数据段)
0x44-0x63: b 的长度 = 5(32 字节)
0x64-0x83: b 的内容 = "hello" + padding(32 字节)
注意:offset 从 calldata 起始位置算(0x00 是 selector 起始)
常见误区
- 误区:动态类型直接放在参数位置;正解:先放 offset,数据段在后面。
- 误区:offset 是相对上一个参数;正解:offset 是从 calldata 起始位置算的绝对偏移。
- 误区:string 内容直接拼接;正解:先放长度,再放内容,padding 到 32 字节倍数。
追问
- 为什么用 offset 机制?答:为了让静态类型参数紧凑在前,合约可以直接按位置读参数,不用跳过动态数据。机制上静态类型参数每个都是 32 字节,合约可以直接
calldataload(4 + i*32)读第 i 个参数。边界在于:动态类型需要先读 offset 再跳到数据段。延伸:这是 ABI 编码的核心设计。 - 嵌套动态数组怎么编码?答:数组本身是动态类型,放 offset;数组元素如果也是动态类型,每个元素再放 offset。机制上 offset 是相对 calldata 起始的绝对位置。边界在于:嵌套越深,offset 链越长,解码越复杂。延伸:这也是为什么 ABI 编码库很重要。
- calldata 与 memory 编码有什么区别?答:calldata 是 ABI 编码(紧凑、offset),memory 是 EVM 内部表示(数组长度 + 元素连续排列)。机制上 Solidity 会自动在 calldata 与 memory 之间转换。边界在于:external 函数用 calldata 参数(省 Gas),internal 函数用 memory。延伸:这是 15.4.1 数据位置的核心。
15.3.3-003 fallback 和 receive 有什么区别?
一句话结论
receive 只在收 ETH 且 data 为空时触发(payable 函数,msg.data 为空);fallback 在 selector 不匹配(调用了合约不存在的函数)或收 ETH + data 非空时触发。简单说:receive 是"纯收 ETH",fallback 是"收未知调用"。
概念解释
- receive:只在收 ETH 且 data 为空时触发,是 fallback 的特例。
- fallback:在 selector 不匹配(合约没有该函数)或收 ETH + data 非空时触发。
- payable:只有 payable 的 fallback/receive 才能收 ETH;非 payable 时收 ETH 会 revert。
- 触发顺序:收 ETH + data 空 → 先找 receive,没有再找 fallback;selector 不匹配 → fallback。
原理流程
- EOA 转 ETH 给合约(data 为空):合约先找 receive,有就触发;没有再找 payable fallback。
- EOA 调用合约不存在的函数(selector 不匹配):触发 fallback。
- EOA 转 ETH + 带 data:触发 payable fallback(不会触发 receive)。
- 如果 fallback/receive 不是 payable,收 ETH 时 revert。
- 现代 Solidity 推荐:用 receive 收 ETH,用 fallback 处理未知调用(如代理转发)。
代码或图示
contract Token {
event Received(address from, uint amount);
// 只收 ETH,data 为空
receive() external payable {
emit Received(msg.sender, msg.value);
}
// 未知函数调用(selector 不匹配)或收 ETH + data 非空
fallback() external payable {
// 代理模式:转发到实现合约
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize())
let result := delegatecall(gas(), sload(implementation_slot), ptr, calldatasize(), 0, 0)
returndatacopy(0, 0, returndatasize())
switch result case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) }
}
}
}
常见误区
- 误区:fallback 和 receive 一样;正解:receive 只收 ETH,fallback 收未知调用。
- 误区:fallback 不能 payable;正解:fallback 可以 payable,收 ETH + data 非空时触发。
- 误区:receive 是 Solidity 新版本才有的;正解:Solidity 0.6 引入 receive,之前只有 fallback。
追问
- 为什么要区分 receive 和 fallback?答:因为收 ETH 与处理未知调用是两种语义;fallback 原来既收 ETH 又处理未知调用,容易混淆。机制上 receive 是显式的"收 ETH"语义,fallback 是"兜底"语义。边界在于:如果合约只需要收 ETH,用 receive;如果需要代理转发,用 fallback。延伸:这是 Solidity 语法的演进。
- 代理模式为什么用 fallback?答:因为代理合约没有业务函数,所有调用都 fallback 触发,然后 delegatecall 到实现合约。机制上 fallback 是"未知函数调用"的兜底,正好用于转发。边界在于:receive 只在 data 为空时触发,代理模式需要转发任意 calldata,所以用 fallback。延伸:这是 15.4.2 代理模式的核心。
- 不收 ETH 的合约会怎样?答:如果 fallback/receive 不是 payable,EOA 转 ETH 给合约会 revert;但合约可以通过 selfdestruct 强制收到 ETH(历史行为,EIP-6780 后受限)。机制上 payable 是收 ETH 的前提。边界在于:有些合约(如多签钱包)需要收 ETH,必须 payable。延伸:这是合约设计的基本决策。
15.3.3-004 selector 碰撞是什么?概率有多高?
一句话结论
selector 只有 4 字节(约 40 亿种),不同函数可能算出相同 selector;当合约数量足够多时,碰撞概率不低。恶意合约可以部署一个与目标合约 selector 碰撞的函数,让调用方误调用。
概念解释
- 碰撞:两个不同函数签名算出相同的 4 字节 selector。
- 概率:生日悖论下,约 7.7 万个不同函数就有 50% 概率碰撞。
- 攻击:攻击者部署一个合约,其中一个函数的 selector 与目标合约的某个函数相同,让调用方误调用。
- 防护:调用前检查合约代码(eth_getCode)、用 ERC-165 接口检测、或验证返回值。
原理流程
- selector 空间是 2^32 ≈ 40 亿种。
- 生日悖论:n 个函数两两碰撞的概率 ≈ n^2 / (2 × 2^32)。
- n = 77000 时,碰撞概率 ≈ 50%。
- 恶意合约:攻击者部署一个合约,其中一个函数 selector 与目标合约的
transfer(address,uint256)相同,但做的是恶意操作。 - 调用方误调用恶意函数,导致资金损失。
代码或图示
生日悖论估算:
selector 空间 = 2^32 ≈ 4.3 × 10^9
n 个函数碰撞概率 ≈ n^2 / (2 × 4.3 × 10^9)
n = 1000:概率 ≈ 0.01%(很低)
n = 10000:概率 ≈ 1.2%
n = 77000:概率 ≈ 50%
攻击场景:
目标合约有函数 transfer(address,uint256) = 0xa9059cbb
攻击者找一个函数签名,其 keccak256 前 4 字节也是 0xa9059cbb
部署恶意合约,调用方误调用
常见误区
- 误区:selector 碰撞概率很低;正解:生日悖论下,几万函数就有 50% 概率碰撞。
- 误区:碰撞是随机的;正解:攻击者可以主动找碰撞签名,恶意部署。
- 误区:碰撞只影响函数调用;正解:事件、错误的 selector 也可能碰撞。
追问
- 怎么防 selector 碰撞?答:三个手段:调用前检查合约代码(eth_getCode 确认是目标地址)、用 ERC-165 接口检测(确认合约实现了预期接口)、验证返回值(如 transfer 返回 true/false)。机制上碰撞只能让调用方误调用同名函数,不能伪造返回值。边界在于:如果调用方不检查返回值,就会被骗。延伸:这是 15.5 合约安全的重点。
- 为什么不把 selector 加长?答:因为 4 字节是工程取舍——再长浪费 calldata,再短碰撞更多。机制上 4 字节约 40 亿种,是"够用但不浪费"。边界在于:随着合约数量增长,碰撞概率上升。延伸:这就是为什么 EOF 要引入新的寻址机制。
- 事件 selector 也会碰撞吗?答:会,事件的 topic 0 也是 keccak256(事件签名) 前 32 字节(不是 4 字节),碰撞概率极低但不为零。机制上事件 topic 0 是 32 字节,空间是 2^256,碰撞概率可忽略。边界在于:4 字节 selector 碰撞是函数层面的问题,事件层面是 32 字节 topic。延伸:这就是为什么事件用 32 字节而不是 4 字节。
15.3.3-005 calldata 为什么是只读的?数组切片怎么用?
一句话结论
calldata 是调用方传进来的字节流,EVM 层面只读(CALLDATALOAD 只能读,不能写);Solidity 的 external 函数用 calldata 参数,省得把数据拷贝到 memory。数组切片(calldata 数组)是 Solidity 0.8+ 的语法,直接引用 calldata 的一段,不拷贝。
概念解释
- calldata:调用输入的只读字节流,EVM 层面只有 CALLDATALOAD/CALLDATACOPY 读操作。
- external 函数:参数默认 calldata,省 Gas(不用拷贝到 memory)。
- 数组切片:
calldataArray[start:end]直接引用 calldata 的一段,不拷贝数据。 - memory:可读写的字节数组,函数内临时用。
原理流程
- EOA 调用合约函数,calldata 是 calldata 字节流(selector + 参数)。
- Solidity external 函数的参数是 calldata 类型,直接引用 calldata,不拷贝。
- 如果要修改数据,必须拷贝到 memory(
memory x = calldataArg)。 - 数组切片:
calldataArray[start:end]直接引用 calldata 的一段,不拷贝。 - internal 函数不能用 calldata 参数(因为没有 calldata 上下文)。
代码或图示
contract C {
// external 函数:参数是 calldata(只读,省 Gas)
function f(uint[] calldata data) external pure returns (uint) {
// data[0] = 1; // 错误:calldata 只读
uint x = data[0]; // 读 OK
// 数组切片:直接引用 calldata 的一段,不拷贝
uint[] calldata slice = data[1:3];
// slice 也是 calldata 类型,只读
}
// internal 函数:不能用 calldata 参数
function g(uint[] memory data) internal pure {
// data 是 memory,可读写
}
}
常见误区
- 误区:calldata 就是 memory 的只读版;正解:calldata 是调用方直接传进来的字节流,不需要 EVM 再拷贝,因此更便宜。
- 误区:external 函数可以用 memory 参数;正解:external 函数参数默认 calldata,用 memory 要显式拷贝,更贵。
- 误区:数组切片会拷贝数据;正解:calldata 数组切片直接引用,不拷贝。
追问
- 为什么 calldata 是只读的?答:因为 calldata 是调用方传进来的,合约不能修改调用方的数据;EVM 层面只有读操作。机制上这是安全设计——合约不能篡改调用方的输入。边界在于:合约可以把 calldata 拷贝到 memory 再修改。延伸:这是 ABI 编码的基础。
- external 函数为什么用 calldata 更便宜?答:因为 calldata 直接引用调用方传进来的数据,不需要 EVM 再拷贝到 memory。机制上 memory 参数要先从 calldata 拷贝,再在 memory 里操作。边界在于:如果函数要修改数据,必须用 memory。延伸:这是 15.4.4 Gas 优化的重点。
- 数组切片有什么用?答:用于处理大数组的一部分,不需要拷贝整个数组;如处理交易的一部分 calldata。机制上切片直接引用 calldata 的一段,省 Gas。边界在于:切片是只读的,不能修改。延伸:这是 Solidity 0.8+ 的语法优化。
15.3.3-006 Error(string) 和 Panic(uint32) 有什么区别?
一句话结论
revert("...") 与 require(cond, "...") 抛出 Error(string)(selector = keccak256("Error(string)")[:4]),用于业务错误;assert(cond) 抛出 Panic(uint32)(selector = keccak256("Panic(uint256)")[:4]),用于内部错误(如溢出、除零)。
概念解释
- Error(string):业务错误,如 require 失败,字符串是错误信息。
- Panic(uint32):内部错误码,如 0x11 = 溢出、0x12 = 除零。
- 自定义 error:Solidity 0.8+ 支持,如
error InsufficientBalance(uint256 required, uint256 available),省 Gas。 - 错误选择器:与函数 selector 一样,是 keccak256(错误签名) 前 4 字节。
原理流程
- require(cond, "insufficient balance"):cond 失败时 revert,数据 = Error selector + 编码的字符串。
- assert(cond):cond 失败时 revert,数据 = Panic selector + 错误码(如 0x11 溢出)。
- 自定义 error:error InsufficientBalance(...); revert InsufficientBalance(...); 数据 = 自定义 selector + 编码参数。
- try/catch 可以捕获这些错误,解码错误数据。
代码或图示
Error(string):
selector = keccak256("Error(string)")[:4] = 0x08c379a0
数据 = [0x08c379a0][offset(32 字节)][长度(32 字节)][错误字符串]
Panic(uint32):
selector = keccak256("Panic(uint256)")[:4] = 0x4e487b71
数据 = [0x4e487b71][错误码(32 字节)]
错误码:0x01 = assert 失败,0x11 = 溢出,0x12 = 除零,0x32 = 数组越界
自定义 error:
error InsufficientBalance(uint256 required, uint256 available)
selector = keccak256("InsufficientBalance(uint256,uint256)")[:4]
数据 = [selector][required][available]
常见误区
- 误区:require 和 assert 一样;正解:require 是业务错误(Error),assert 是内部错误(Panic)。
- 误区:错误字符串是自由文本;正解:Error(string) 的字符串是 ABI 编码的动态类型。
- 误区:自定义 error 与 Error(string) 一样;正解:自定义 error 省 Gas(没有字符串长度与数据段)。
追问
- 为什么 assert 用 Panic 而不是 Error?答:因为 assert 是"不应该发生"的内部错误(如溢出、除零),不是业务错误;Panic 是让开发者知道"代码有 bug"。机制上 require 是预期的业务检查,assert 是防御性检查。边界在于:生产代码应该用 require 做业务检查,assert 做内部不变量检查。延伸:这是 Solidity 错误处理的设计哲学。
- 自定义 error 为什么省 Gas?答:因为没有字符串长度与数据段;自定义 error 的参数直接编码,没有动态类型开销。机制上 Error(string) 要编码字符串(offset + 长度 + 内容),自定义 error 只编码参数。边界在于:自定义 error 更省 Gas,但错误信息是结构化的(不是人类可读字符串)。延伸:这是 15.4.4 Gas 优化的重点。
- try/catch 怎么捕获错误?答:try externalCall returns (返回值) { 成功 } catch Error(string memory reason) { 业务错误 } catch Panic(uint code) { 内部错误 } { 其它错误 }。机制上 try/catch 把低级 call 的返回值判断与错误解码编译成高级语法。边界在于:try/catch 只能捕获外部调用(external call)的错误,不能捕获内部 require。延伸:这是 Solidity 0.6+ 的错误处理。
15.3.3-007 事件的 topic 0 是什么?与 selector 有什么关系?
一句话结论
事件的 topic 0 = keccak256(事件签名) 的 32 字节(不是前 4 字节),用于识别事件类型;topic 1-3 是索引参数(最多 3 个)。事件的 topic 0 与函数 selector 的计算方式相同(keccak256),但长度是 32 字节(不是 4 字节),碰撞概率可忽略。
概念解释
- 事件签名:如
Transfer(address indexed from, address indexed to, uint256 value)。 - topic 0 = keccak256(事件签名) 32 字节,识别事件类型。
- topic 1-3:索引参数(最多 3 个),可以在日志过滤时按 topic 查询。
- data:非索引参数,存在日志 data 字段,不能直接按 topic 过滤。
原理流程
- 定义事件:event Transfer(address indexed from, address indexed to, uint256 value)。
- 计算 topic 0 = keccak256("Transfer(address,address,uint256)")。
- 触发事件时:log 记录 topic 0 + topic 1 (from) + topic 2 (to) + data (value)。
- 外部查询时:可以按 topic 0(事件类型)+ topic 1(from)过滤。
- 非索引参数存在 data 字段,不能直接按 topic 过滤。
代码或图示
事件 Transfer(address indexed from, address indexed to, uint256 value):
topic 0 = keccak256("Transfer(address,address,uint256)") (32 字节)
topic 1 = from (address,20 字节,padding 到 32 字节)
topic 2 = to (address,padding 到 32 字节)
data = value (uint256,ABI 编码)
查询:
eth_getLogs({
topics: [
keccak256("Transfer(address,address,uint256)"), // 事件类型
null, // from 任意
"0x000000000000000000000000..." // to = 某地址
]
})
常见误区
- 误区:topic 0 是 4 字节 selector;正解:topic 0 是 32 字节,碰撞概率可忽略。
- 误区:所有参数都能按 topic 过滤;正解:最多 3 个 indexed 参数(topic 1-3),非索引参数存在 data。
- 误区:事件签名带参数名;正解:事件签名只带参数类型,不带参数名。
追问
- 为什么事件用 32 字节而不是 4 字节?答:因为事件数量比函数多,且事件查询是按 topic 过滤的,需要低碰撞概率;4 字节在事件层面碰撞概率太高。机制上 32 字节空间是 2^256,碰撞概率可忽略。边界在于:事件日志的存储成本比函数调用高(topic 0 占 32 字节)。延伸:这是事件日志的设计取舍。
- 为什么最多 3 个 indexed 参数?答:因为日志最多 4 个 topic(topic 0 + topic 1-3),3 个是工程取舍。机制上 topic 越多,日志存储成本越高。边界在于:如果需要更多索引参数,可以把多个参数打包成 bytes32(如两个 address 打包)。延伸:这是事件设计的权衡。
- 非索引参数存在哪里?答:存在日志的 data 字段,不能直接按 topic 过滤;外部要解析 data 才能拿到。机制上 data 是 ABI 编码的非索引参数。边界在于:非索引参数查询时要拉所有日志再过滤,成本高。延伸:这是为什么重要参数要 indexed。
15.3.3-008 DELEGATECALL 调用栈里 msg.sender 是谁?
一句话结论
DELEGATECALL 调用栈里,msg.sender 保持原始 EOA 不变(不变成代理合约),address(this) 也保持代理合约不变,storage 归属是代理合约。这是代理模式能透传用户身份的关键。
概念解释
- 调用链:EOA → Proxy → Impl(DELEGATECALL)。
- msg.sender:每一层都保持原始 EOA(DELEGATECALL 不改变 msg.sender)。
- address(this):每一层都保持代理合约(DELEGATECALL 不改变 address(this))。
- storage:Impl 的代码操作代理合约的存储槽。
原理流程
- EOA 调用 Proxy.transfer(to, amount)。
- Proxy 没有 transfer 函数,fallback 触发,DELEGATECALL 到 Impl。
- Impl 执行 transfer 代码:msg.sender = EOA(不是 Proxy),address(this) = Proxy(不是 Impl)。
- Impl 修改的 storage 槽 = Proxy 的槽位。
- 这样用户身份透传到 Impl,状态存在 Proxy 上。
代码或图示
调用链:
EOA (0x1111) → Proxy (0x2222) → Impl (0x3333)
在 Impl.transfer 代码里:
msg.sender = 0x1111(EOA,不是 Proxy)
address(this) = 0x2222(Proxy,不是 Impl)
storage slot = Proxy 的槽位
为什么?
DELEGATECALL 的语义:在调用者的上下文里执行被调用者的代码
上下文 = msg.sender + address(this) + storage
这些都保持调用者(Proxy)的值,不变成被调用者(Impl)
常见误区
- 误区:DELEGATECALL 后 msg.sender 变成 Proxy;正解:msg.sender 保持原始 EOA。
- 误区:DELEGATECALL 后 address(this) 变成 Impl;正解:address(this) 保持 Proxy。
- 误区:DELEGATECALL 的 storage 是 Impl 的;正解:storage 是 Proxy 的。
追问
- 为什么 DELEGATECALL 保持 msg.sender 不变?答:因为代理模式要让 Impl 知道原始用户是谁;如果 msg.sender 变成 Proxy,Impl 就无法验证用户身份。机制上 DELEGATECALL 的语义是"在调用者的上下文里执行",上下文包括 msg.sender。边界在于:这也意味着 Impl 可以用 msg.sender 做权限检查(如 onlyOwner)。延伸:这是代理模式的核心。
- 为什么 DELEGATECALL 的 storage 是 Proxy 的?答:因为代理模式要让状态存在 Proxy 上(升级时代理存储不变);如果 storage 是 Impl 的,升级时数据要迁移。机制上 DELEGATECALL 让 Impl 的代码操作 Proxy 的槽位。边界在于:这要求 Impl 与 Proxy 的存储布局一致(否则读错槽位)。延伸:这就是
__gap与 EIP-1967 的原因。 - 怎么验证 DELEGATECALL 的上下文?答:在 Impl 里加一个测试函数,返回 msg.sender、address(this)、storage slot 的值;通过 Proxy 调用,验证这些值是否符合预期。机制上测试可以确认代理模式的正确性。边界在于:存储布局不一致是最常见的代理 bug。延伸:这是 15.5 合约安全的重点。
15.3.3-009 低级 call 失败时怎么正确处理?
一句话结论
低级 call 返回 (bool ok, bytes memory returndata),必须检查 ok;如果 ok 为 false,要解码 returndata(是 Error(string)、Panic(uint32) 还是自定义 error),然后决定是 revert 还是降级。生产代码应该 require(ok, ...) 或用 try/catch。
概念解释
- ok:call 是否成功(true = 成功,false = revert)。
- returndata:被调用合约返回的数据(成功时是返回值,失败时是错误数据)。
- 错误解码:returndata 可能是 Error(string)、Panic(uint32)、自定义 error。
- try/catch:Solidity 高级语法,把这些判断编译成高级语法。
原理流程
- (bool ok, bytes memory returndata) = target.call(data);
- 检查 ok:false 则被调用合约 revert。
- 解码 returndata:如果是 Error selector,解码错误字符串;如果是 Panic selector,解码错误码。
- 决定处理:require(ok) 让全部回滚;或降级处理(记录日志、继续执行)。
- try/catch 自动做这些:try target.call(data) returns (...) { 成功 } catch { 失败 }。
代码或图示
contract C {
// 低级 call 正确处理
function safeTransfer(address to, uint amount) external {
(bool ok, bytes memory returndata) = to.call{value: amount}("");
if (!ok) {
// 解码错误数据
if (returndata.length > 0) {
// 用 assembly 或库解码 Error(string) / Panic(uint32)
assembly {
revert(add(returndata, 0x20), mload(returndata))
}
}
revert("transfer failed");
}
}
// try/catch 高级写法
function tryTransfer(address to, uint amount) external {
try to.call{value: amount}("") {
// 成功
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("transfer failed");
}
}
}
常见误区
- 误区:低级 call 失败会自动 revert;正解:低级 call 返回 false,调用者自己决定。
- 误区:只检查 ok 就够了;正解:还要解码 returndata,否则错误信息丢失。
- 误区:try/catch 能捕获所有错误;正解:try/catch 只能捕获外部调用错误,不能捕获内部 require。
追问
- 为什么低级 call 不自动 revert?答:因为调用者可能想做降级处理(如记录日志、继续执行),而不是全部回滚。机制上低级 call 是底层操作,把错误处理交给调用者。边界在于:这也意味着忘记检查 ok 是安全风险。延伸:生产代码应该 require(ok) 或 try/catch。
- returndata 怎么解码?答:检查前 4 字节 selector:0x08c379a0 = Error(string),0x4e487b71 = Panic(uint32);自定义 error 用对应的 selector。机制上解码是 ABI 解码的逆过程。边界在于:手动解码很麻烦,推荐用库(如 OpenZeppelin 的 Address library)。延伸:try/catch 自动做这些。
- 什么时候不 require(ok)?答:当调用者想降级处理时(如外部预言机调用失败,用备用价格);但必须显式记录失败,不能静默忽略。机制上降级处理是业务决策。边界在于:忘记检查 ok 是最常见的合约 bug。延伸:这是 15.5 合约安全的重点。
15.3.3-010 CREATE2 盐地址怎么预测?怎么防 clash?
一句话结论
CREATE2 地址 = keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:],任何人都可以离线算出目标地址;防 clash 的方法是用一次性盐(包含随机数),或部署前检查目标地址是否已被占用。
概念解释
- salt:部署者提供的 32 字节随机数,影响地址。
- initcode 哈希:keccak256(initcode),与 salt 一起决定地址。
- clash:目标地址已有代码或余额时,CREATE2 失败。
- 前置攻击:攻击者提前算出目标地址,存 1 wei 占用。
原理流程
- 部署者准备 initcode 与 salt,离线算出目标地址。
- 任何人都可以离线算:keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:]。
- 如果目标地址已有代码或余额,CREATE2 失败。
- 防护:用一次性盐(salt = keccak256(random ++ block.timestamp)),让攻击者无法预测;或部署前 eth_getCode(目标) == 0。
- 部署交易加 nonce 约束(只允许特定区块号部署)。
代码或图示
CREATE2 地址推导:
address = keccak256(
0xff ++ deployer ++ salt(32 字节) ++ keccak256(initcode)
)[12:]
防 clash:
1. 一次性盐:salt = keccak256(abi.encode(random_nonce, msg.sender))
→ 攻击者无法预测 salt,地址无法前置
2. 部署前检查:eth_getCode(target_address) == 0
→ 确认目标地址未被占用
3. 区块号约束:只在特定区块号部署(如 require(block.number == target_block))
→ 限制前置窗口
例:
deployer = 0x1111, salt = keccak256(random), initcode = 0x...
target = keccak256(0xff ++ 0x1111 ++ salt ++ keccak256(initcode))[12:]
常见误区
- 误区:CREATE2 地址不可预测;正解:任何人都可以离线算。
- 误区:用固定盐部署最安全;正解:固定盐最容易被前置攻击。
- 误区:CREATE2 一定能部署成功;正解:目标地址非空就失败。
追问
- 为什么要离线算地址?答:因为 CREATE2 的优势是"确定性部署"——跨链同地址、提前算好地址用于签名。机制上盐固定则地址固定,方便集成。边界在于:这也引入了前置攻击风险。延伸:这就是为什么要一次性盐。
- 一次性盐怎么生成?答:salt = keccak256(abi.encode(random_nonce, msg.sender, block.number));random_nonce 由部署者私下保管。机制上盐不可预测,地址不可前置。边界在于:如果盐可预测(如固定盐、区块号),前置就可行。延伸:生产用 CREATE2 都要带随机盐。
- 跨链同地址部署为什么重要?答:因为很多协议(如钱包工厂、预言机)希望在不同链上用同一个合约地址,简化集成。机制上 CREATE2 让同一 deployer + salt + initcode 在不同链上部署到同一地址。边界在于:跨链部署要确保 deployer 与 initcode 一致。延伸:这是 CREATE2 的核心用途。
动手练习
练习 1:手算 selector 并解码 calldata
- 任务:找一个主网交易,用 keccak256 算出 selector,确认与 Etherscan 显示的函数一致;解码 calldata 里的参数。
- 验收标准:
- 能手算常用函数(transfer、approve、balanceOf)的 selector。
- 能解码静态类型与动态类型参数。
- 能解释 offset 机制。
练习 2:写一个带 fallback 的代理合约
- 任务:用 Solidity 写一个极简代理,fallback 里 delegatecall 到实现合约;测试 msg.sender 与 address(this) 是否符合预期。
- 验收标准:
- 能写出 fallback 里的 assembly 转发逻辑。
- 能验证 DELEGATECALL 后 msg.sender 保持 EOA。
- 能解释为什么 storage 是代理合约的。
自检清单
- [ ] 能手算函数选择器,并解释碰撞概率?
- [ ] 能画出动态类型的 ABI 编码布局(offset + 数据段)?
- [ ] 能区分 fallback 与 receive 的触发条件?
- [ ] 能解释 selector 碰撞的原理与防护?
- [ ] 能说明 calldata 为什么只读,以及数组切片的用途?
- [ ] 能区分 Error(string) 与 Panic(uint32),以及自定义 error 的优势?
- [ ] 能解释事件 topic 0 与函数 selector 的关系?
- [ ] 能说明 DELEGATECALL 调用栈里 msg.sender 为什么不变?
- [ ] 能写出低级 call 的正确错误处理?
- [ ] 能推导 CREATE2 地址,并说明防 clash 的方法?
延伸阅读
- Solidity 官方文档:Contract ABI、Events、Error Handling。
- EIP-1967:代理存储槽标准。
- ERC-165:接口检测标准。
- Ethereum Yellow Paper:ABI 编码规范。
- OpenZeppelin Contracts:Address library、代理合约实现。
待整理清单
- [ ] 补充常用函数 selector 速查表(按当前主网常用合约)
- [ ] 补充事件 topic 过滤的实际 RPC 查询示例
- [ ] 补充 Solidity 0.8+ 自定义 error 的最佳实践