15.3.4 状态树、收据与事件日志
所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.3 以太坊与 EVM
本节要解决的问题
面试里问"状态存在哪里",多数人答"存在区块里"。这是错的。真正的分水岭是:能不能说清以太坊用 Merkle Patricia Trie(MPT)存状态,三棵树(state、storage、receipts)各自存什么,以及为什么区块头里只有三个 root 而不是完整数据。本节解决四个具体问题:一是分清 MPT 与普通 Merkle 树的区别(Patricia 压缩前缀路径);二是讲清区块头里 stateRoot、transactionsRoot、receiptsRoot 各自指向什么;三是把收据结构(status、cumulativeGasUsed、logs、bloom)与事件日志(address、topics、data)串起来;四是说明 logs bloom 的误判率与查询原理,以及 archive 节点为什么需要完整历史。
学习目标
学完本节,你应当能够:
- 画出三棵 MPT 的结构:state 树(地址 → 账户)、storage 树(合约 → 槽位)、receipts 树(交易 → 收据)。
- 写出区块头里三个 root 的含义,并说明为什么只存 root 不存完整数据。
- 描述收据的结构(status、cumulativeGasUsed、logs、bloom)与事件日志的结构(address、topics[4]、data)。
- 解释 logs bloom 的工作原理(bit array 哈希),以及为什么有误判率。
先修与前置
- 建议先读 15.1.1 区块链结构与 Merkle 树,理解 Merkle 树的基本原理。
- 本节是 15.3.5 节点客户端、RPC 与索引 的前置,先懂状态树再看节点同步。
知识地图
以太坊数据结构:
区块头 ──┬── stateRoot → state MPT:地址 → 账户(nonce/balance/storageRoot/codeHash)
├── transactionsRoot → tx MPT:交易索引 → 交易
└── receiptsRoot → receipts MPT:交易索引 → 收据
账户结构(RLP 编码):
nonce, balance, storageRoot, codeHash
每个合约有自己的 storage MPT:
storageRoot(在 state 树里)→ 槽位 → 值
收据结构(RLP 编码):
status, cumulativeGasUsed, logsBloom, logs[]
事件日志结构:
address, topics[0..3], data
logsBloom = 对 address + topics 做 bit 哈希
轻节点验证:
只下载区块头(root),用 Merkle 证明验证交易/收据存在
核心术语
- MPT(Merkle Patricia Trie):以太坊的状态存储结构,结合 Merkle 树的哈希验证与 Patricia 树的前缀压缩。
- stateRoot:区块头里指向 state MPT 根的哈希,代表该区块结束时的全局状态。
- storageRoot:每个账户(合约)的 storage MPT 根哈希,存在 state 树里。
- receiptsRoot:区块头里指向 receipts MPT 根的哈希,代表该区块所有交易的收据。
- 收据(Receipt):每笔交易的执行结果,包含 status、cumulativeGasUsed、logs、logsBloom。
- 事件日志(Log):合约触发的事件记录,包含 address、topics、data。
- logsBloom:一个 256 字节的 bit array,对 address + topics 哈希后设位,用于快速过滤日志。
- archive 节点:保留所有历史状态(每个区块的 stateRoot)的节点,full 节点只保留最新状态。
- Merkle 证明:轻节点用根哈希 + 兄弟节点哈希验证某条数据存在。
覆盖范围
- MPT 的结构与 Patricia 压缩原理
- 三棵树的关系:state、storage、receipts
- 区块头三个 root 的含义
- 账户结构(nonce、balance、storageRoot、codeHash)
- 收据结构与事件日志结构
- logsBloom 的工作原理与误判率
- archive 节点 vs full 节点
- 轻节点与 Merkle 证明
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 15.3.4-001 | 以太坊的三棵 MPT 分别存什么? | 基础 | ★★★★★ |
| 15.3.4-002 | 区块头里的 stateRoot、transactionsRoot、receiptsRoot 是什么? | 基础 | ★★★★★ |
| 15.3.4-003 | 收据(Receipt)的结构是什么? | 基础 | ★★★★ |
| 15.3.4-004 | 事件日志的结构是什么?topics 与 data 的区别? | 进阶 | ★★★★★ |
| 15.3.4-005 | logsBloom 是怎么过滤日志的?误判率多少? | 进阶 | ★★★★ |
| 15.3.4-006 | 合约的 storage 树是怎么隔离的? | 进阶 | ★★★★ |
| 15.3.4-007 | 账户结构里有什么?codeHash 是什么? | 进阶 | ★★★ |
| 15.3.4-008 | archive 节点为什么需要完整历史? | 高级 | ★★★★ |
| 15.3.4-009 | 轻节点怎么用 Merkle 证明验证交易? | 高级 | ★★★ |
| 15.3.4-010 | 状态修剪(state expiry)是什么?为什么需要? | 高级 | ★★★ |
15.3.4-001 以太坊的三棵 MPT 分别存什么?
一句话结论
以太坊有三棵 MPT:state MPT(地址 → 账户)、storage MPT(每个合约 → 槽位)、receipts MPT(交易索引 → 收据)。state MPT 的根哈希是 stateRoot,存在区块头里;每个合约的 storage MPT 根哈希存在 state 树的账户里;receipts MPT 的根哈希是 receiptsRoot,也存在区块头里。
概念解释
- state MPT:key = keccak256(地址),value = RLP(账户结构);全局只有一棵。
- storage MPT:每个合约有一棵,key = 槽位号,value = RLP(值);根哈希存在 state 树的账户里。
- receipts MPT:key = 交易索引(RLP 编码),value = RLP(收据);每区块一棵。
- 为什么用 MPT:既支持哈希验证(任何节点都能验证某条数据存在),又支持前缀压缩(节省存储)。
原理流程
- 全局只有一棵 state MPT,key 是 keccak256(地址),value 是账户结构(nonce、balance、storageRoot、codeHash)。
- 每个合约账户有自己的 storage MPT,根哈希存在 state 树的 storageRoot 字段。
- 每区块有一棵 receipts MPT,key 是交易索引(0、1、2...),value 是收据。
- 区块头存 stateRoot(全局状态根)、receiptsRoot(本区块收据根)。
- 交易数据本身也有一棵 tx MPT(transactionsRoot),key 是交易索引,value 是交易。
代码或图示
三棵 MPT:
state MPT(全局一棵):
key = keccak256(地址)
value = RLP([nonce, balance, storageRoot, codeHash])
例:
keccak256(0x1111...) → [0, 100 ETH, 0xaaa..., 0xbbb...]
keccak256(0x2222...) → [5, 0 ETH, 0xccc..., 0xddd...] ← 合约账户
storage MPT(每个合约一棵):
key = 槽位号(uint256)
value = RLP(槽位值)
根哈希存在 state 树的 storageRoot
receipts MPT(每区块一棵):
key = RLP(交易索引) // 0, 1, 2...
value = RLP(收据)
根哈希 = receiptsRoot(在区块头里)
常见误区
- 误区:所有数据都在一棵 MPT 里;正解:三棵树(state、storage、receipts),storage 是每个合约一棵。
- 误区:state 树里直接存槽位值;正解:state 树里只存账户结构,槽位值在单独的 storage 树里。
- 误区:receipts 树是全局的;正解:receipts 树是每区块一棵,根哈希存在区块头。
追问
- 为什么用 Patricia 压缩而不是普通 Merkle 树?答:因为以太坊地址与槽位是 256 位,普通 Merkle 树会有大量空路径;Patricia 树压缩公共前缀,节省节点数量。机制上 Patricia 树是前缀树,把公共路径合并。边界在于:压缩让节点查找更快,但实现复杂。延伸:这是以太坊存储效率的核心。
- 为什么 key 用 keccak256(地址) 而不是直接地址?答:因为 MPT 的 key 是 hex 编码的 nibble(半字节),用 keccak256(地址) 让 key 均匀分布,避免前缀攻击。机制上 keccak256(地址) 是 32 字节,均匀分布在 2^256 空间。边界在于:这也让外部无法直接从 key 推出地址(要遍历)。延伸:这是密码学安全的设计。
- 三棵树的修改是原子的吗?答:是的,每区块结束时,三棵树的根哈希都更新到区块头;如果区块里任何交易 revert,状态树回滚到区块开始。机制上 MPT 是持久化数据结构(修改产生新根,旧根保留)。边界在于:这也是 archive 节点能保留历史状态的原因。延伸:这是 15.3.4-008 的主题。
15.3.4-002 区块头里的 stateRoot、transactionsRoot、receiptsRoot 是什么?
一句话结论
区块头里有三个 root:stateRoot(全局状态根哈希,指向 state MPT)、transactionsRoot(交易列表根哈希,指向 tx MPT)、receiptsRoot(收据根哈希,指向 receipts MPT)。这三个 root 是 Merkel 树的根,任何节点都可以用它们验证某条数据存在,而不需要下载完整数据。
概念解释
- stateRoot:state MPT 的根哈希,代表该区块结束时的全局状态。
- transactionsRoot:tx MPT 的根哈希,代表该区块的交易列表。
- receiptsRoot:receipts MPT 的根哈希,代表该区块的所有收据。
- 轻节点:只下载区块头(root),用 Merkle 证明验证交易/收据存在。
原理流程
- 区块头包含三个 root:stateRoot、transactionsRoot、receiptsRoot。
- 这三个 root 是各自 MPT 的根哈希。
- 轻节点只下载区块头,不下载完整数据。
- 要验证某笔交易存在,轻节点向全节点请求 Merkle 证明(交易 + 兄弟节点哈希)。
- 用 root + 兄弟节点哈希计算出的哈希等于 root,验证通过。
代码或图示
区块头结构(简化):
parentHash, ommersHash, beneficiary, stateRoot,
transactionsRoot, receiptsRoot, logsBloom, difficulty,
number, gasLimit, gasUsed, timestamp, extraData, mixHash, nonce
三个 root:
stateRoot → state MPT(全局状态)
transactionsRoot → tx MPT(交易列表)
receiptsRoot → receipts MPT(收据列表)
轻节点验证:
轻节点下载区块头(含 receiptsRoot)
向全节点请求:某交易的收据 + Merkle 证明
用 receiptsRoot + 兄弟节点哈希计算 → 等于 receiptsRoot → 验证通过
常见误区
- 误区:区块头里存了完整数据;正解:区块头只存三个 root,完整数据在区块体里。
- 误区:stateRoot 是交易的哈希;正解:stateRoot 是全局状态的根哈希,与交易无关。
- 误区:三个 root 都在区块体里;正解:三个 root 在区块头里,区块体是交易列表。
追问
- 为什么只存 root 不存完整数据?答:因为区块头要被所有节点下载(包括轻节点),如果存完整数据,区块头会很大;root 只有 32 字节,轻节点可以快速验证。机制上 Merkle 树的根哈希代表整个数据结构,任何修改都会改变 root。边界在于:轻节点要向全节点请求数据才能验证。延伸:这是轻节点设计的核心。
- stateRoot 每区块都变吗?答:是的,任何交易修改状态(余额、存储)都会改变 stateRoot;即使交易 revert,stateRoot 也会变(因为 gas 被消耗)。机制上 stateRoot 是该区块结束时的全局状态快照。边界在于:这也是为什么 archive 节点要保留每个区块的 stateRoot。延伸:这是 15.3.4-008 的主题。
- 三个 root 之间有什么关系?答:stateRoot 与 receiptsRoot 是独立的——stateRoot 代表状态,receiptsRoot 代表执行结果;transactionsRoot 是交易列表。机制上交易列表是输入,收据是输出,状态是结果。边界在于:三者在区块头里并列,没有依赖关系。延伸:这是区块链数据结构的经典设计。
15.3.4-003 收据(Receipt)的结构是什么?
一句话结论
每笔交易都有一个收据,记录执行结果:status(成功/失败)、cumulativeGasUsed(累计 Gas)、logsBloom(日志过滤器)、logs[](事件日志列表)。收据存在 receipts MPT 里,根哈希是 receiptsRoot,在区块头里。
概念解释
- status:1 = 成功,0 = 失败(EIP-658 引入,之前用 postState 根哈希)。
- cumulativeGasUsed:该区块到这笔交易为止的累计 Gas 消耗。
- logsBloom:该收据里所有日志的 bloom 过滤器(256 字节 bit array)。
- logs[]:事件日志列表,每个日志包含 address、topics、data。
原理流程
- 交易执行结束,生成收据。
- 收据记录 status(成功/失败)、cumulativeGasUsed(累计 Gas)。
- 收据里的 logs[] 记录所有触发的事件日志。
- 收据的 logsBloom 是该收据所有日志的 bloom 过滤器。
- 收据存入 receipts MPT,根哈希更新到区块头。
代码或图示
收据结构(RLP 编码):
[
status, // 1 = 成功, 0 = 失败
cumulativeGasUsed, // 该区块到这笔交易的累计 Gas
logsBloom, // 256 字节 bit array
logs: [ // 事件日志列表
[address, [topic0, topic1, ...], data],
...
]
]
例:
一笔 ERC20 transfer 成功的收据:
status = 1
cumulativeGasUsed = 52000
logsBloom = ...(256 字节)
logs = [
[
0xToken地址,
[keccak256("Transfer(address,address,uint256)"), from, to],
amount
]
]
常见误区
- 误区:收据就是交易回执;正解:收据是执行结果,包含 status、gas、logs。
- 误区:status 是 transaction hash;正解:status 是 1 或 0,表示成功或失败。
- 误区:logs 在交易里;正解:logs 在收据里,不在交易里。
追问
- 为什么要有收据?答:因为交易本身只记录输入,不记录输出;收据记录执行结果(成功/失败、Gas、事件),让外部可以查询。机制上收据是执行结果的权威记录。边界在于:收据存在 receipts MPT 里,根哈希在区块头。延伸:这是 DApp 查询事件的依据。
- EIP-658 为什么用 status 代替 postState?答:旧规则下收据里存 postState(交易后的状态根哈希),需要全节点保留历史状态;EIP-658 改成 status(1/0),不再需要历史状态。机制上 status 是简单的成功/失败,不需要完整状态。边界在于:这也让 full 节点可以修剪历史状态。延伸:这是 15.3.4-010 状态修剪的前置。
- cumulativeGasUsed 有什么用?答:用于计算单笔交易的 Gas 消耗 = 本笔 cumulativeGasUsed - 上一笔 cumulativeGasUsed。机制上区块里的交易按顺序执行,累计 Gas 递增。边界在于:这也是区块 gasUsed 的计算方式。延伸:这是 Gas 计费的依据。
15.3.4-004 事件日志的结构是什么?topics 与 data 的区别?
一句话结论
事件日志包含 address(合约地址)、topics[0..3](索引参数,最多 4 个)、data(非索引参数)。topics 是 32 字节的哈希值,可以按 topic 过滤;data 是 ABI 编码的非索引参数,不能直接按 topic 过滤。
概念解释
- address:触发事件的合约地址。
- topics[0]:事件签名的 keccak256(32 字节),识别事件类型。
- topics[1..3]:索引参数(最多 3 个),可以按 topic 过滤。
- data:非索引参数的 ABI 编码,不能直接按 topic 过滤。
原理流程
- 合约触发事件:emit Transfer(from, to, value)。
- EVM 生成日志:address = 合约地址,topics[0] = keccak256("Transfer(address,address,uint256)"),topics[1] = from,topics[2] = to,data = value。
- 日志加入收据的 logs[]。
- 外部查询时:可以按 topics[0](事件类型)+ topics[1](from)过滤。
- data 字段要解析才能拿到非索引参数。
代码或图示
事件日志结构:
{
address: "0xToken地址",
topics: [
"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", // Transfer 事件签名
"0x000000000000000000000000Alice地址", // from
"0x000000000000000000000000Bob地址" // to
],
data: "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000" // value = 100 ETH
}
查询:
eth_getLogs({
address: "0xToken地址",
topics: [
"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", // Transfer
null, // from 任意
"0x000000000000000000000000Bob地址" // to = Bob
]
})
常见误区
- 误区:topics 都是参数;正解:topics[0] 是事件签名,topics[1..3] 是索引参数。
- 误区:data 也能按 topic 过滤;正解:data 不能直接按 topic 过滤,要解析后再过滤。
- 误区:事件可以有任意多索引参数;正解:最多 3 个索引参数(topics[1..3])。
追问
- 为什么索引参数存在 topics 而不是 data?答:因为 topics 可以直接按哈希过滤(外部查询时按 topic 查),data 要解析才能过滤。机制上 topics 是 32 字节哈希,直接匹配;data 是 ABI 编码,要解码。边界在于:索引参数越多,日志存储成本越高。延伸:这是事件设计的权衡。
- 非索引参数为什么存在 data?答:因为 data 可以存任意长度的 ABI 编码(如 string、bytes);topics 只能存 32 字节哈希。机制上 data 是完整的参数编码,要解析。边界在于:大参数(如 string)只能存在 data。延伸:这是为什么重要参数要 indexed。
- 事件日志与交易回执有什么区别?答:交易回执是每笔交易的执行结果(status、gas、logs);事件日志是回执里的 logs[] 列表。机制上日志是回执的一部分。边界在于:一笔交易可以触发多个事件日志。延伸:这是 DApp 监听事件的依据。
15.3.4-005 logsBloom 是怎么过滤日志的?误判率多少?
一句话结论
logsBloom 是一个 256 字节(2048 bit)的 bit array,对日志的 address + 每个 topic 做 keccak256 哈希,取前 11 位作为 bit 位置,设位。查询时对查询条件做同样的哈希,如果对应 bit 都是 1,说明"可能匹配"。误判率约 0.1%(因为不同值可能哈希到同一 bit)。
概念解释
- Bloom filter:一种概率数据结构,用 bit array 表示集合,支持"可能存在"与"一定不存在"。
- 256 字节 = 2048 bit。
- 每个值做 keccak256,取前 11 位(0-2047)作为 bit 位置,设位。
- 查询:如果所有查询条件的 bit 都是 1,说明"可能匹配";否则"一定不匹配"。
- 误判率:约 0.1%(不同值哈希到同一 bit)。
原理流程
- 生成 bloom:对日志的 address + 每个 topic 做 keccak256,取前 11 位,设位。
- 查询:对查询条件(如 address、topic)做同样的哈希。
- 检查所有 bit:如果都是 1,说明"可能匹配"(要拉日志确认)。
- 如果有任何 bit 是 0,说明"一定不匹配"(跳过)。
- 误判率:约 0.1%,因为不同值可能哈希到同一 bit。
代码或图示
logsBloom 工作原理:
256 字节 = 2048 bit 的 bit array
生成 bloom:
对 address 做 keccak256,取前 11 位 → bit 位置 X → 设 bit[X] = 1
对 topic0 做 keccak256,取前 11 位 → bit 位置 Y → 设 bit[Y] = 1
对 topic1 做 keccak256,取前 11 位 → bit 位置 Z → 设 bit[Z] = 1
查询:
对查询条件 address' 做 keccak256,取前 11 位 → bit 位置 X'
检查 bit[X'] == 1?
是 → 可能匹配(拉日志确认)
否 → 一定不匹配(跳过)
误判率:
2048 bit,每个值设 3 个 bit(不同哈希函数)
误判率 ≈ 0.1%
常见误区
- 误区:logsBloom 是精确匹配;正解:是概率过滤器,有误判率。
- 误区:bloom 说"匹配"就一定匹配;正解:bloom 说"可能匹配",要拉日志确认。
- 误区:bloom 说"不匹配"可能是错的;正解:bloom 说"一定不匹配"是精确的(没有漏报)。
追问
- 为什么用 bloom filter 而不是直接存日志?答:因为 bloom filter 很小(256 字节),可以快速过滤掉不匹配的区块,不用拉每个区块的日志。机制上全节点先用 bloom 过滤,只拉可能匹配的区块日志。边界在于:误判率约 0.1%,要拉日志确认。延伸:这是 DApp 查询事件的性能优化。
- 误判率为什么是 0.1%?答:因为 2048 bit 的 bloom filter,每个值设 3 个 bit(不同哈希函数),当集合填满时,误判率约 0.1%。机制上误判率随集合大小增长。边界在于:区块里日志越多,误判率越高。延伸:这是 bloom filter 的数学性质。
- 为什么不用更大的 bloom?答:因为 bloom 要存在区块头里(logsBloom 字段),256 字节是工程取舍;再大区块头会膨胀。机制上 256 字节 = 2048 bit,足够低误判率。边界在于:这是存储成本与查询效率的权衡。延伸:这是区块链数据结构的经典设计。
15.3.4-006 合约的 storage 树是怎么隔离的?
一句话结论
每个合约有自己的 storage MPT,key = 槽位号(uint256),value = 槽位值;storage 树的根哈希存在 state 树的账户结构里(storageRoot 字段)。这样不同合约的存储完全隔离,互不干扰。
概念解释
- storage MPT:每个合约一棵,key = 槽位号,value = RLP(槽位值)。
- storageRoot:存在 state 树的账户结构里,指向该合约的 storage MPT。
- 隔离:不同合约的 storage 树独立,互不影响。
- 槽位号:Solidity 按变量顺序分配槽位(slot 0、slot 1...)。
原理流程
- state 树里,合约账户的 value 包含 storageRoot 字段。
- storageRoot 指向该合约的 storage MPT 根。
- storage MPT 的 key = 槽位号(如 0、1、2...),value = RLP(槽位值)。
- 不同合约的 storage 树独立,根哈希不同。
- DELEGATECALL 时,代码操作的是调用者(代理)的 storage 树,不是实现合约的。
代码或图示
合约 A(0x1111)的存储:
state 树:keccak256(0x1111) → [nonce, balance, storageRoot_A, codeHash_A]
storageRoot_A → storage MPT A:
slot 0 → RLP(变量1)
slot 1 → RLP(变量2)
...
合约 B(0x2222)的存储:
state 树:keccak256(0x2222) → [nonce, balance, storageRoot_B, codeHash_B]
storageRoot_B → storage MPT B:
slot 0 → RLP(变量X)
slot 1 → RLP(变量Y)
...
隔离:合约 A 与合约 B 的 storage 树完全独立
常见误区
- 误区:所有合约共用一棵 storage 树;正解:每个合约一棵,根哈希在 state 树里。
- 误区:storage 树的 key 是变量名;正解:key 是槽位号(uint256)。
- 误区:DELEGATECALL 操作实现合约的存储;正解:DELEGATECALL 操作调用者(代理)的存储树。
追问
- 为什么每个合约一棵 storage 树?答:因为要隔离——不同合约的存储互不干扰,且可以单独验证某合约的存储状态。机制上 storageRoot 在 state 树里,轻节点可以验证某合约的存储状态。边界在于:这也让 archive 节点的存储成本很高(每个合约一棵)。延伸:这是 15.3.4-008 的主题。
- 槽位号是怎么分配的?答:Solidity 按变量声明顺序分配槽位(slot 0、slot 1...);mapping 与动态数组用 keccak256(key) 计算槽位号。机制上静态变量顺序分配,动态变量用哈希计算。边界在于:升级代理合约时,变量顺序不能变(否则读错槽位)。延伸:这是
__gap的原因。 - 怎么验证某合约的存储状态?答:用 stateRoot + storageRoot + Merkle 证明:轻节点下载区块头的 stateRoot,向全节点请求某合约的账户(含 storageRoot)+ Merkle 证明,再请求某槽位的值 + Merkle 证明。机制上两级 Merkle 证明。边界在于:这是轻节点验证合约状态的方式。延伸:这是 15.3.4-009 的主题。
15.3.4-007 账户结构里有什么?codeHash 是什么?
一句话结论
state 树里的账户结构包含 nonce(交易计数)、balance(余额)、storageRoot(存储树根)、codeHash(合约代码哈希)。EOA 的 codeHash 是空(0x0),合约账户的 codeHash 是合约代码的 keccak256。
概念解释
- nonce:EOA 是交易计数,合约是创建计数。
- balance:账户的 ETH 余额。
- storageRoot:合约的存储树根(EOA 为空)。
- codeHash:合约代码的 keccak256(EOA 为 0x0)。
原理流程
- state 树的 value 是 RLP 编码的账户结构:[nonce, balance, storageRoot, codeHash]。
- EOA:storageRoot 为空,codeHash 为 0x0。
- 合约:storageRoot 指向存储树,codeHash 是合约代码的 keccak256。
- 外部可以用 codeHash 验证合约代码是否正确。
- 合约代码本身存在链上(通过 EXTCODECOPY 读取),codeHash 只是哈希。
代码或图示
账户结构(RLP 编码):
[nonce, balance, storageRoot, codeHash]
EOA(0x1111):
[
5, // nonce = 5(发过 5 笔交易)
1000000000000000000, // balance = 1 ETH
0x0000000000000000000000000000000000000000000000000000000000000000, // storageRoot 空
0x0000000000000000000000000000000000000000000000000000000000000000 // codeHash 空
]
合约(0x2222):
[
0, // nonce = 0
0, // balance = 0
0xaaa...aaa, // storageRoot = 存储树根
0xbbb...bbb // codeHash = 合约代码 keccak256
]
常见误区
- 误区:EOA 也有 codeHash;正解:EOA 的 codeHash 为 0x0,没有代码。
- 误区:codeHash 就是合约代码;正解:codeHash 是合约代码的哈希,代码本身存在链上。
- 误区:合约的 nonce 是交易计数;正解:合约的 nonce 是创建计数(CREATE 时用)。
追问
- 为什么要有 codeHash?答:因为外部可以用 codeHash 验证合约代码是否正确(如验证部署的代码与预期一致);同时 EXTCODEHASH 操作码可以快速检查合约代码是否变化。机制上 codeHash 是合约代码的哈希。边界在于:合约代码不可变(除了 SELFDESTRUCT),codeHash 不变。延伸:这是合约可验证性的基础。
- 合约代码存在哪里?答:合约代码存在链上(通过 EXTCODECOPY 读取),但不在 state 树里;state 树里只存 codeHash。机制上合约代码是单独的存储(字节码),不在 MPT 里。边界在于:这也是为什么合约部署要付代码存储费(约 200 Gas/字节)。延伸:这是 15.3.2 的主题。
- 怎么验证某合约是 EOA 还是合约?答:用 EXTCODEHASH 操作码——如果 codeHash 为 0x0,是 EOA;否则是合约。机制上 EOA 的 codeHash 为 0x0。边界在于:这也是为什么有些攻击合约伪装成 EOA(实际上是合约)。延伸:这是合约安全的重点。
15.3.4-008 archive 节点为什么需要完整历史?
一句话结论
archive 节点保留每个区块的 stateRoot 对应的完整状态(可以查询任何历史区块的状态);full 节点只保留最新状态(只能查询当前状态)。archive 节点需要完整历史是因为:很多应用(如区块浏览器、数据分析)需要查询历史状态。
概念解释
- full 节点:只保留最新状态(当前 stateRoot),可以修剪旧状态。
- archive 节点:保留每个区块的完整状态(所有历史 stateRoot),磁盘占用大。
- 用途:区块浏览器、数据分析、重放交易需要历史状态。
- 成本:archive 节点磁盘占用大(TB 级),同步时间长。
原理流程
- full 节点:只保留最新 stateRoot,旧的 stateRoot 对应的 MPT 被修剪。
- archive 节点:保留所有历史 stateRoot 对应的 MPT,可以查询任何历史区块的状态。
- 为什么需要:区块浏览器要查"某地址在某区块的余额",数据分析要重放交易。
- 成本:archive 节点磁盘占用 TB 级,同步时间长(几周)。
- 趋势:EIP-4444 等机制试图修剪历史状态,降低 archive 成本。
代码或图示
full 节点 vs archive 节点:
full 节点:
只保留最新 stateRoot(当前区块)
旧 stateRoot 对应的 MPT 被修剪
磁盘占用:几百 GB
能查:当前状态
archive 节点:
保留所有历史 stateRoot 对应的 MPT
磁盘占用:TB 级
能查:任何历史区块的状态
例:
查"Alice 在区块 100 万时的余额":
full 节点:查不到(旧 stateRoot 被修剪)
archive 节点:可以查到
常见误区
- 误区:所有节点都能查历史状态;正解:只有 archive 节点能查历史状态。
- 误区:full 节点与 archive 节点性能一样;正解:archive 节点磁盘占用大得多。
- 误区:archive 节点是必须的;正解:普通用户用 full 节点或托管 RPC 即可。
追问
- 为什么 full 节点要修剪历史?答:因为完整历史状态的磁盘占用太大(TB 级),普通节点承担不起;修剪后只保留最新状态,磁盘占用几百 GB。机制上 MPT 是持久化数据结构,旧根哈希对应的节点可以被修剪。边界在于:这也意味着 full 节点不能查历史状态。延伸:这是节点成本与功能的权衡。
- 什么时候需要 archive 节点?答:区块浏览器、数据分析、重放交易、合约调试需要历史状态。机制上这些应用要查"某地址在某区块的状态"。边界在于:普通 DApp 只用最新状态,不需要 archive 节点。延伸:这也是为什么托管 RPC(如 Infura、Alchemy)提供 archive 节点服务。
- EIP-4444 是什么?答:EIP-4444 试图修剪历史状态(把旧状态从全节点移除),降低 archive 成本;具体机制以当前 EIP 状态为准。机制上旧状态可以从其他来源(如托管服务)获取,不需要全节点保留。边界在于:这是以太坊长期可扩展性的一部分。延伸:这是 15.3.4-010 的主题。
15.3.4-009 轻节点怎么用 Merkle 证明验证交易?
一句话结论
轻节点只下载区块头(含 root),不下载完整数据;要验证某笔交易存在,向全节点请求"交易 + Merkle 证明(兄弟节点哈希)",用 root + 兄弟节点哈希计算出的哈希等于 root,验证通过。
概念解释
- 轻节点:只下载区块头(root),不下载完整数据。
- Merkle 证明:交易 + 兄弟节点哈希列表,可以从叶子节点计算到根。
- 验证:用 root + 兄弟节点哈希计算,等于 root 则验证通过。
- 用途:轻节点(手机、浏览器)验证交易,不需要同步完整区块链。
原理流程
- 轻节点下载区块头,拿到 receiptsRoot。
- 要验证某笔交易的收据,向全节点请求"收据 + Merkle 证明"。
- Merkle 证明是兄弟节点哈希列表,从叶子(收据)到根(receiptsRoot)。
- 轻节点用收据 + 兄弟节点哈希计算出的哈希,等于 receiptsRoot,验证通过。
- 不需要下载完整 receipts MPT。
代码或图示
Merkle 证明示例:
receiptsRoot = H4
MPT:
H4 = H(H2, H3)
H2 = H(H0, H1)
H0 = 收据 0
H1 = 收据 1
H3 = H(H2', H3')...
要验证收据 1:
轻节点请求:收据 1 + Merkle 证明
Merkle 证明 = [H0, H3]
轻节点计算:
H2 = H(H0, H1)
H4 = H(H2, H3)
H4 == receiptsRoot?→ 验证通过
常见误区
- 误区:轻节点要下载完整区块链;正解:轻节点只下载区块头。
- 误区:Merkle 证明是加密的;正解:Merkle 证明是兄弟节点哈希列表,任何人都能计算。
- 误区:轻节点验证是可信的;正解:轻节点信任全节点提供的证明,但 root 是协议共识的。
追问
- 为什么需要轻节点?答:因为普通节点要同步完整区块链(几百 GB 到 TB),手机/浏览器承担不起;轻节点只下载区块头(几 KB/区块),快速同步。机制上轻节点用 Merkle 证明验证交易。边界在于:轻节点要信任全节点提供的证明。延伸:这是区块链可扩展性的一部分。
- 轻节点能验证什么?答:轻节点能验证交易存在(通过 receiptsRoot)、状态存在(通过 stateRoot);不能验证"交易不存在"(要完整扫描)。机制上 Merkle 证明只能证明"存在"。边界在于:这是轻节点的限制。延伸:这就是为什么需要汇总服务(如 light client servers)。
- 轻节点与 SPV 有什么区别?答:SPV(Simplified Payment Verification)是比特币的轻节点概念,用 Merkle 证明验证交易;以太坊的轻节点类似,但用 MPT 而不是普通 Merkle 树。机制上两者原理相同,都是用 root + 证明验证。边界在于:以太坊的轻节点实现正在演进(如 Portal Network)。延伸:这是以太坊去中心化的一部分。
15.3.4-010 状态修剪(state expiry)是什么?为什么需要?
一句话结论
状态修剪是把旧状态(历史 stateRoot 对应的 MPT)从全节点移除,降低节点存储成本;因为完整历史状态的磁盘占用太大(TB 级),普通节点承担不起。EIP-4444 等机制正在推进状态修剪,具体以当前 EIP 状态为准。
概念解释
- 状态修剪:把旧 stateRoot 对应的 MPT 节点从全节点移除。
- 为什么:完整历史状态磁盘占用 TB 级,普通节点承担不起。
- 趋势:EIP-4444 等机制试图修剪历史状态,让节点只保留近期状态。
- 挑战:修剪后怎么查历史状态(从其他来源获取)。
原理流程
- 现在:full 节点保留最新状态,archive 节点保留所有历史状态。
- 问题:archive 节点磁盘占用 TB 级,同步时间长。
- 趋势:EIP-4444 试图修剪历史状态,全节点只保留近期状态(如最近几个月)。
- 挑战:修剪后怎么查历史状态(从托管服务、其他节点获取)。
- 目标:降低节点成本,让更多人能运行节点。
代码或图示
状态修剪的趋势:
现在:
full 节点:只保留最新状态(几百 GB)
archive 节点:保留所有历史状态(TB 级)
未来(EIP-4444 等):
全节点:只保留近期状态(如最近 1 年)
旧状态:从托管服务、其他节点获取
目标:降低节点成本,让更多人能运行节点
常见误区
- 误区:状态修剪是删除数据;正解:状态修剪是把旧状态从全节点移除,但数据仍可从其他来源获取。
- 误区:状态修剪会影响轻节点;正解:轻节点只下载区块头,不依赖全节点的历史状态。
- 误区:状态修剪已经实现;正解:EIP-4444 等机制正在推进,具体以当前 EIP 状态为准。
追问
- 为什么需要状态修剪?答:因为完整历史状态的磁盘占用太大(TB 级),普通节点承担不起;修剪后节点成本降低,更多人能运行节点。机制上 MPT 是持久化数据结构,旧根对应的节点可以被修剪。边界在于:修剪后历史状态要从其他来源获取。延伸:这是以太坊长期可扩展性的一部分。
- 修剪后怎么查历史状态?答:从托管服务(如 Infura、Alchemy)、其他 archive 节点、或专用历史节点获取。机制上修剪不删除数据,只是全节点不保留。边界在于:这需要信任托管服务。延伸:这是去中心化与成本的权衡。
- EIP-4444 的具体机制是什么?答:EIP-4444 试图修剪历史状态,让全节点只保留近期状态;具体机制(如保留多久、怎么获取旧状态)以当前 EIP 状态为准。机制上这是以太坊长期可扩展性的一部分。边界在于:这是一个长期演进的过程,不是一步到位。延伸:这是以太坊治理的一部分。
动手练习
练习 1:用 Etherscan 查一笔交易的收据
- 任务:找一笔主网交易,查看它的收据(status、cumulativeGasUsed、logs、logsBloom),解码事件日志。
- 验收标准:
- 能写出收据的四个字段。
- 能解码事件日志的 topics 与 data。
- 能解释 logsBloom 的作用。
练习 2:画一棵 MPT 的结构
- 任务:用 3 个 key-value 对画一棵 MPT,标出 Patricia 压缩的部分;说明 root 是怎么计算的。
- 验收标准:
- 能画出 extension 节点与 leaf 节点。
- 能解释 Patricia 压缩的原理。
- 能说明 root 哈希怎么验证。
自检清单
- [ ] 能画出三棵 MPT 的结构,并说明各自存什么?
- [ ] 能写出区块头三个 root 的含义?
- [ ] 能写出收据的结构?
- [ ] 能解释事件日志的 topics 与 data 的区别?
- [ ] 能说明 logsBloom 的工作原理与误判率?
- [ ] 能解释合约 storage 树的隔离机制?
- [ ] 能写出账户结构的四个字段?
- [ ] 能说明 full 节点与 archive 节点的区别?
- [ ] 能解释轻节点怎么用 Merkle 证明验证交易?
- [ ] 能说明状态修剪的趋势与动机?
延伸阅读
- Ethereum Yellow Paper:MPT 结构、收据格式。
- EIP-658:收据 status 替代 postState。
- EIP-4444:历史状态修剪(待确认)。
- Ethereum 文档:Trie、Receipts、Logs。
- 《Mastering Ethereum》:Merkle Patricia Trie 章节。
待整理清单
- [ ] 补充 MPT 节点类型(extension/leaf/branch)的详细结构
- [ ] 补充 logsBloom 误判率的精确计算
- [ ] 补充 EIP-4444 的当前状态(待确认)