罗罗编程学习记录 全栈面试题库
本页导航 展开查看

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)。

先修与前置

知识地图

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。

原理流程

  1. 写出函数签名:transfer(address,uint256)(注意:参数类型不带变量名,不带空格)。
  2. 对签名做 keccak256 哈希,得到 32 字节。
  3. 取前 4 字节,就是 selector。
  4. 调用时 calldata 前 4 字节是 selector,后面是参数编码。
  5. 合约收到调用时,用 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 是相对位置。

原理流程

  1. 调用 f(uint a, string calldata b):a 是静态类型,b 是动态类型。
  2. 编码布局:[selector][a(32 字节)][offset_to_b(32 字节)][b 的数据]。
  3. offset_to_b 指向 b 数据段的起始位置(从 calldata 开始算字节数)。
  4. b 的数据段:先放长度(32 字节),再放内容(padding 到 32 字节倍数)。
  5. 多个动态参数时,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。

原理流程

  1. EOA 转 ETH 给合约(data 为空):合约先找 receive,有就触发;没有再找 payable fallback。
  2. EOA 调用合约不存在的函数(selector 不匹配):触发 fallback。
  3. EOA 转 ETH + 带 data:触发 payable fallback(不会触发 receive)。
  4. 如果 fallback/receive 不是 payable,收 ETH 时 revert。
  5. 现代 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 接口检测、或验证返回值。

原理流程

  1. selector 空间是 2^32 ≈ 40 亿种。
  2. 生日悖论:n 个函数两两碰撞的概率 ≈ n^2 / (2 × 2^32)。
  3. n = 77000 时,碰撞概率 ≈ 50%。
  4. 恶意合约:攻击者部署一个合约,其中一个函数 selector 与目标合约的 transfer(address,uint256) 相同,但做的是恶意操作。
  5. 调用方误调用恶意函数,导致资金损失。

代码或图示

生日悖论估算:
  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:可读写的字节数组,函数内临时用。

原理流程

  1. EOA 调用合约函数,calldata 是 calldata 字节流(selector + 参数)。
  2. Solidity external 函数的参数是 calldata 类型,直接引用 calldata,不拷贝。
  3. 如果要修改数据,必须拷贝到 memory(memory x = calldataArg)。
  4. 数组切片:calldataArray[start:end] 直接引用 calldata 的一段,不拷贝。
  5. 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 字节。

原理流程

  1. require(cond, "insufficient balance"):cond 失败时 revert,数据 = Error selector + 编码的字符串。
  2. assert(cond):cond 失败时 revert,数据 = Panic selector + 错误码(如 0x11 溢出)。
  3. 自定义 error:error InsufficientBalance(...); revert InsufficientBalance(...); 数据 = 自定义 selector + 编码参数。
  4. 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 过滤。

原理流程

  1. 定义事件:event Transfer(address indexed from, address indexed to, uint256 value)。
  2. 计算 topic 0 = keccak256("Transfer(address,address,uint256)")。
  3. 触发事件时:log 记录 topic 0 + topic 1 (from) + topic 2 (to) + data (value)。
  4. 外部查询时:可以按 topic 0(事件类型)+ topic 1(from)过滤。
  5. 非索引参数存在 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 的代码操作代理合约的存储槽。

原理流程

  1. EOA 调用 Proxy.transfer(to, amount)。
  2. Proxy 没有 transfer 函数,fallback 触发,DELEGATECALL 到 Impl。
  3. Impl 执行 transfer 代码:msg.sender = EOA(不是 Proxy),address(this) = Proxy(不是 Impl)。
  4. Impl 修改的 storage 槽 = Proxy 的槽位。
  5. 这样用户身份透传到 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 高级语法,把这些判断编译成高级语法。

原理流程

  1. (bool ok, bytes memory returndata) = target.call(data);
  2. 检查 ok:false 则被调用合约 revert。
  3. 解码 returndata:如果是 Error selector,解码错误字符串;如果是 Panic selector,解码错误码。
  4. 决定处理:require(ok) 让全部回滚;或降级处理(记录日志、继续执行)。
  5. 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 占用。

原理流程

  1. 部署者准备 initcode 与 salt,离线算出目标地址。
  2. 任何人都可以离线算:keccak256(0xff ++ deployer ++ salt ++ keccak256(initcode))[12:]。
  3. 如果目标地址已有代码或余额,CREATE2 失败。
  4. 防护:用一次性盐(salt = keccak256(random ++ block.timestamp)),让攻击者无法预测;或部署前 eth_getCode(目标) == 0。
  5. 部署交易加 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 里的参数。
  • 验收标准:
    1. 能手算常用函数(transfer、approve、balanceOf)的 selector。
    2. 能解码静态类型与动态类型参数。
    3. 能解释 offset 机制。

练习 2:写一个带 fallback 的代理合约

  • 任务:用 Solidity 写一个极简代理,fallback 里 delegatecall 到实现合约;测试 msg.sender 与 address(this) 是否符合预期。
  • 验收标准:
    1. 能写出 fallback 里的 assembly 转发逻辑。
    2. 能验证 DELEGATECALL 后 msg.sender 保持 EOA。
    3. 能解释为什么 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 的最佳实践