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

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 哈希),以及为什么有误判率。

先修与前置

知识地图

以太坊数据结构:
  区块头 ──┬── 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:既支持哈希验证(任何节点都能验证某条数据存在),又支持前缀压缩(节省存储)。

原理流程

  1. 全局只有一棵 state MPT,key 是 keccak256(地址),value 是账户结构(nonce、balance、storageRoot、codeHash)。
  2. 每个合约账户有自己的 storage MPT,根哈希存在 state 树的 storageRoot 字段。
  3. 每区块有一棵 receipts MPT,key 是交易索引(0、1、2...),value 是收据。
  4. 区块头存 stateRoot(全局状态根)、receiptsRoot(本区块收据根)。
  5. 交易数据本身也有一棵 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 证明验证交易/收据存在。

原理流程

  1. 区块头包含三个 root:stateRoot、transactionsRoot、receiptsRoot。
  2. 这三个 root 是各自 MPT 的根哈希。
  3. 轻节点只下载区块头,不下载完整数据。
  4. 要验证某笔交易存在,轻节点向全节点请求 Merkle 证明(交易 + 兄弟节点哈希)。
  5. 用 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。

原理流程

  1. 交易执行结束,生成收据。
  2. 收据记录 status(成功/失败)、cumulativeGasUsed(累计 Gas)。
  3. 收据里的 logs[] 记录所有触发的事件日志。
  4. 收据的 logsBloom 是该收据所有日志的 bloom 过滤器。
  5. 收据存入 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 过滤。

原理流程

  1. 合约触发事件:emit Transfer(from, to, value)。
  2. EVM 生成日志:address = 合约地址,topics[0] = keccak256("Transfer(address,address,uint256)"),topics[1] = from,topics[2] = to,data = value。
  3. 日志加入收据的 logs[]。
  4. 外部查询时:可以按 topics[0](事件类型)+ topics[1](from)过滤。
  5. 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)。

原理流程

  1. 生成 bloom:对日志的 address + 每个 topic 做 keccak256,取前 11 位,设位。
  2. 查询:对查询条件(如 address、topic)做同样的哈希。
  3. 检查所有 bit:如果都是 1,说明"可能匹配"(要拉日志确认)。
  4. 如果有任何 bit 是 0,说明"一定不匹配"(跳过)。
  5. 误判率:约 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...)。

原理流程

  1. state 树里,合约账户的 value 包含 storageRoot 字段。
  2. storageRoot 指向该合约的 storage MPT 根。
  3. storage MPT 的 key = 槽位号(如 0、1、2...),value = RLP(槽位值)。
  4. 不同合约的 storage 树独立,根哈希不同。
  5. 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)。

原理流程

  1. state 树的 value 是 RLP 编码的账户结构:[nonce, balance, storageRoot, codeHash]。
  2. EOA:storageRoot 为空,codeHash 为 0x0。
  3. 合约:storageRoot 指向存储树,codeHash 是合约代码的 keccak256。
  4. 外部可以用 codeHash 验证合约代码是否正确。
  5. 合约代码本身存在链上(通过 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 级),同步时间长。

原理流程

  1. full 节点:只保留最新 stateRoot,旧的 stateRoot 对应的 MPT 被修剪。
  2. archive 节点:保留所有历史 stateRoot 对应的 MPT,可以查询任何历史区块的状态。
  3. 为什么需要:区块浏览器要查"某地址在某区块的余额",数据分析要重放交易。
  4. 成本:archive 节点磁盘占用 TB 级,同步时间长(几周)。
  5. 趋势: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 则验证通过。
  • 用途:轻节点(手机、浏览器)验证交易,不需要同步完整区块链。

原理流程

  1. 轻节点下载区块头,拿到 receiptsRoot。
  2. 要验证某笔交易的收据,向全节点请求"收据 + Merkle 证明"。
  3. Merkle 证明是兄弟节点哈希列表,从叶子(收据)到根(receiptsRoot)。
  4. 轻节点用收据 + 兄弟节点哈希计算出的哈希,等于 receiptsRoot,验证通过。
  5. 不需要下载完整 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 等机制试图修剪历史状态,让节点只保留近期状态。
  • 挑战:修剪后怎么查历史状态(从其他来源获取)。

原理流程

  1. 现在:full 节点保留最新状态,archive 节点保留所有历史状态。
  2. 问题:archive 节点磁盘占用 TB 级,同步时间长。
  3. 趋势:EIP-4444 试图修剪历史状态,全节点只保留近期状态(如最近几个月)。
  4. 挑战:修剪后怎么查历史状态(从托管服务、其他节点获取)。
  5. 目标:降低节点成本,让更多人能运行节点。

代码或图示

状态修剪的趋势:

  现在:
    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),解码事件日志。
  • 验收标准:
    1. 能写出收据的四个字段。
    2. 能解码事件日志的 topics 与 data。
    3. 能解释 logsBloom 的作用。

练习 2:画一棵 MPT 的结构

  • 任务:用 3 个 key-value 对画一棵 MPT,标出 Patricia 压缩的部分;说明 root 是怎么计算的。
  • 验收标准:
    1. 能画出 extension 节点与 leaf 节点。
    2. 能解释 Patricia 压缩的原理。
    3. 能说明 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 的当前状态(待确认)