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

15.3.5 节点客户端、RPC 与索引

所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.3 以太坊与 EVM

本节要解决的问题

面试里问"怎么连以太坊",多数人答"用 Infura"。这是入门。真正的分水岭是:能不能说清 full 节点与 archive 节点的区别、Geth 与 reth 的架构差异、JSON-RPC 的常用方法与限流、以及为什么 The Graph 之类的索引服务是 DApp 必备。本节解决四个具体问题:一是分清节点同步模式(full/snap/fast)与它们的取舍;二是讲清 eth_call 的状态模拟原理(它不发交易,只是在 EVM 里跑一遍);三是把 eth_getLogs 的限流与容量限制讲明白(为什么 Infura 不让你查 100 万块的日志);四是说明 The Graph subgraph 的索引原理——它不是实时查 RPC,而是把事件日志索引成数据库。

学习目标

学完本节,你应当能够:

  • 区分 full 节点、archive 节点、轻节点的用途与成本。
  • 列出常用 JSON-RPC 方法(eth_call、eth_getBalance、eth_sendRawTransaction、eth_getLogs)的用途与限制。
  • 解释 eth_call 的状态模拟原理,以及它与真实交易的区别。
  • 说明 The Graph subgraph 的索引原理,以及为什么 DApp 需要它。

先修与前置

知识地图

节点类型:
  full 节点:只保留最新状态,几百 GB
  archive 节点:保留所有历史状态,TB 级
  轻节点:只下载区块头,不下载完整数据

节点同步模式:
  full sync:逐区块执行,慢但完整
  snap sync:从快照同步状态,快
  fast sync:快速同步到最新,再切换 full

JSON-RPC 常用方法:
  eth_call:模拟交易,不发链
  eth_getBalance:查余额
  eth_sendRawTransaction:发交易
  eth_getLogs:查事件日志

索引服务:
  The Graph subgraph:把事件日志索引成数据库
  原理:监听事件日志 → 写入数据库 → DApp 查数据库

核心术语

  • full 节点:只保留最新状态的节点,磁盘占用几百 GB。
  • archive 节点:保留所有历史状态的节点,磁盘占用 TB 级。
  • Geth:Go 语言写的以太坊客户端,最主流。
  • reth:Rust 语言写的以太坊客户端,新一代,性能更高。
  • JSON-RPC:节点对外暴露的 RPC 接口,基于 HTTP/WebSocket。
  • eth_call:模拟交易,不发链,只返回结果。
  • eth_getLogs:查事件日志,有区块范围限制。
  • The Graph:去中心化索引协议,把事件日志索引成数据库。
  • subgraph:The Graph 的索引服务,定义要索引哪些事件。

覆盖范围

  • 节点类型:full、archive、轻节点
  • 节点客户端:Geth、reth、Erigon、Nethermind
  • 同步模式:full sync、snap sync、fast sync
  • JSON-RPC 常用方法与限流
  • eth_call 的状态模拟原理
  • 交易池(mempool)与交易广播
  • The Graph subgraph 索引原理
  • 自建 RPC 节点 vs 托管 RPC 的选型

高频题速览

编号 题目 难度 频率
15.3.5-001 full 节点和 archive 节点有什么区别? 基础 ★★★★★
15.3.5-002 Geth 和 reth 有什么区别? 基础 ★★★★
15.3.5-003 JSON-RPC 常用方法有哪些? 基础 ★★★★★
15.3.5-004 eth_call 是怎么模拟交易的? 进阶 ★★★★
15.3.5-005 eth_getLogs 为什么有区块范围限制? 进阶 ★★★★
15.3.5-006 交易池(mempool)是什么? 进阶 ★★★
15.3.5-007 节点同步模式有哪些? 进阶 ★★★
15.3.5-008 The Graph subgraph 是怎么索引的? 高级 ★★★★
15.3.5-009 自建 RPC 节点 vs 托管 RPC 怎么选? 高级 ★★★
15.3.5-010 节点的状态缓存层有什么用? 高级 ★★★

15.3.5-001 full 节点和 archive 节点有什么区别?

一句话结论

full 节点只保留最新状态(当前 stateRoot),磁盘占用几百 GB;archive 节点保留所有历史状态(每个区块的 stateRoot),磁盘占用 TB 级。full 节点只能查当前状态,archive 节点能查任何历史区块的状态。

概念解释

  • full 节点:只保留最新 stateRoot,旧 stateRoot 对应的 MPT 被修剪。
  • archive 节点:保留所有历史 stateRoot 对应的 MPT。
  • 用途:区块浏览器、数据分析、重放交易需要 archive 节点。
  • 成本:archive 节点磁盘占用 TB 级,同步时间长(几周)。

原理流程

  1. full 节点同步到最新区块后,只保留最新 stateRoot,旧 MPT 节点被修剪。
  2. archive 节点同步时保留所有历史 stateRoot 对应的 MPT。
  3. 查"当前余额":full 节点与 archive 节点都能查。
  4. 查"某区块的余额":只有 archive 节点能查。
  5. 普通 DApp 用 full 节点或托管 RPC 即可,不需要 archive 节点。

代码或图示

full 节点 vs archive 节点:

full 节点:
  磁盘占用:几百 GB
  能查:当前状态
  同步时间:几天
  用途:普通 DApp、验证交易

archive 节点:
  磁盘占用:TB 级
  能查:任何历史区块的状态
  同步时间:几周
  用途:区块浏览器、数据分析、重放交易

例:
  查"Alice 当前余额":full 节点 OK
  查"Alice 在区块 100 万时的余额":只有 archive 节点 OK

常见误区

  • 误区:所有节点都是 archive 节点;正解:只有专门的 archive 节点才保留历史状态。
  • 误区:full 节点性能更好;正解:full 节点与 archive 节点性能一样,只是磁盘占用不同。
  • 误区:archive 节点是必须的;正解:普通用户用 full 节点或托管 RPC 即可。

追问

  • 为什么 full 节点要修剪历史?答:因为完整历史状态的磁盘占用太大(TB 级),普通节点承担不起;修剪后只保留最新状态,磁盘占用几百 GB。机制上 MPT 是持久化数据结构,旧根对应的节点可以被修剪。边界在于:这也意味着 full 节点不能查历史状态。延伸:这是 15.3.4-008 的主题。
  • 什么时候需要 archive 节点?答:区块浏览器、数据分析、重放交易、合约调试需要历史状态。机制上这些应用要查"某地址在某区块的状态"。边界在于:普通 DApp 只用最新状态,不需要 archive 节点。延伸:这也是为什么托管 RPC(如 Infura、Alchemy)提供 archive 节点服务。
  • 运行 archive 节点的成本?答:磁盘 TB 级、同步时间几周、需要大量带宽;自建 archive 节点成本很高。机制上 archive 节点要同步所有历史状态。边界在于:这也是大多数团队用托管 archive 节点的原因。延伸:这是节点运维的成本权衡。

15.3.5-002 Geth 和 reth 有什么区别?

一句话结论

Geth 是 Go 语言写的以太坊客户端,最主流、最成熟;reth 是 Rust 语言写的新一代客户端,性能更高、内存占用更少。两者都实现了以太坊协议,但架构与性能特点不同。

概念解释

  • Geth:Go 语言写,最主流,社区大,文档全。
  • reth:Rust 语言写,新一代,性能更高,内存占用更少。
  • Erigon:Go 语言写,另一个客户端,staged sync 架构,磁盘占用小。
  • Nethermind:C# 语言写,企业级客户端。

原理流程

  1. Geth:最早的以太坊客户端之一,Go 语言实现,社区最大。
  2. reth:新一代 Rust 客户端,优化了状态访问与内存占用。
  3. Erigon:staged sync 架构,把同步分成多个阶段,磁盘占用小。
  4. 它们都实现了以太坊协议,可以互相通信(共识一致)。
  5. 选择取决于团队技术栈与性能需求。

代码或图示

主流以太坊客户端:

  Geth:
    语言:Go
    特点:最主流、最成熟、社区大
    用途:大多数节点运营者

  reth:
    语言:Rust
    特点:性能更高、内存占用更少
    用途:新一代高性能节点

  Erigon:
    语言:Go
    特点:staged sync、磁盘占用小
    用途:archive 节点

  Nethermind:
    语言:C#
    特点:企业级、.NET 生态
    用途:企业用户

常见误区

  • 误区:所有客户端都一样;正解:不同客户端架构不同,性能特点不同。
  • 误区:Geth 是官方唯一客户端;正解:以太坊有多个客户端,都实现了协议。
  • 误区:reth 还不成熟;正解:reth 已经主网运行,性能优秀。

追问

  • 为什么要有多个客户端?答:为了抗中心化——如果只有一个客户端,一个 bug 就会导致全网停机;多个客户端实现协议,增加容错。机制上以太坊协议是规范,多个客户端独立实现。边界在于:这也是以太坊客户端多样性的重要性。延伸:这是以太坊去中心化的一部分。
  • reth 比 Geth 好在哪里?答:reth 用 Rust 实现,优化了状态访问与内存占用,性能更高。机制上 Rust 的内存安全与零成本抽象让节点更高效。边界在于:Geth 社区更大、文档更全。延伸:这是新一代客户端的优势。
  • 怎么选客户端?答:取决于团队技术栈、性能需求、运维经验;Geth 是稳妥选择,reth 是高性能选择。机制上两者都实现了协议,共识一致。边界在于:企业用户可能选 Nethermind(.NET 生态)。延伸:这是节点运维的技术选型。

15.3.5-003 JSON-RPC 常用方法有哪些?

一句话结论

常用 JSON-RPC 方法包括:eth_call(模拟交易)、eth_getBalance(查余额)、eth_sendRawTransaction(发交易)、eth_getLogs(查事件日志)、eth_blockNumber(查最新区块号)、eth_getBlockByNumber(查区块)。

概念解释

  • eth_call:模拟交易,不发链,只返回结果。
  • eth_getBalance:查地址余额。
  • eth_sendRawTransaction:发签名后的交易。
  • eth_getLogs:查事件日志。
  • eth_blockNumber:查最新区块号。

原理流程

  1. DApp 前端通过 HTTP/WebSocket 调用节点的 JSON-RPC。
  2. 常用方法:
    • eth_call:模拟合约调用,查状态。
    • eth_getBalance:查地址余额。
    • eth_sendRawTransaction:发签名后的交易。
    • eth_getLogs:查事件日志。
  3. 节点执行请求,返回结果。
  4. 托管 RPC(如 Infura、Alchemy)提供这些方法的限流版本。

代码或图示

常用 JSON-RPC 方法:

  // 查最新区块号
  {"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}

  // 查余额
  {"jsonrpc":"2.0","method":"eth_getBalance","params":["0x1111...","latest"],"id":1}

  // 模拟调用(查 balanceOf)
  {"jsonrpc":"2.0","method":"eth_call","params":[{
    "to": "0xToken...",
    "data": "0x70a082310000000000000000000000001111..."
  },"latest"],"id":1}

  // 发交易
  {"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":["0xSignedTx..."],"id":1}

  // 查事件日志
  {"jsonrpc":"2.0","method":"eth_getLogs","params":[{
    "address": "0xToken...",
    "fromBlock": "0x1000000",
    "toBlock": "0x1001000",
    "topics": ["0xddf252ad..."]
  }],"id":1}

常见误区

  • 误区:eth_call 会发交易;正解:eth_call 只是模拟,不发链。
  • 误区:eth_getLogs 可以查任意范围;正解:托管 RPC 有区块范围限制。
  • 误区:JSON-RPC 是 WebSocket;正解:JSON-RPC 可以用 HTTP 或 WebSocket。

追问

  • 为什么有 HTTP 与 WebSocket 两种?答:HTTP 用于请求-响应(如查余额),WebSocket 用于订阅事件(如新区块、新日志)。机制上 HTTP 无状态,WebSocket 长连接。边界在于:订阅事件要用 WebSocket。延伸:这是 DApp 实时更新的基础。
  • 托管 RPC 为什么要限流?答:因为节点资源有限,要防止单个用户滥用;限流方式包括 QPS 限制、区块范围限制、并发限制。机制上托管 RPC 是共享服务,要保护节点。边界在于:免费 tier 限流很严,付费 tier 更宽松。延伸:这是 RPC 服务的商业模式。
  • 怎么批量调用?答:JSON-RPC 支持批量请求(一个数组里多个请求),减少 HTTP 开销。机制上批量请求在一个 HTTP 连接里发多个调用。边界在于:托管 RPC 可能限制批量大小。延伸:这是 DApp 性能优化的一部分。

15.3.5-004 eth_call 是怎么模拟交易的?

一句话结论

eth_call 在 EVM 里跑一遍合约代码,但不真正发交易(不修改状态、不消耗 Gas、不进区块);它把状态回滚到调用前,返回执行结果。用于 DApp 查状态(如 balanceOf、getPrice)。

概念解释

  • eth_call:在 EVM 里执行合约代码,但不修改状态、不消耗 Gas。
  • 原理:创建一个临时执行上下文,跑完后回滚状态。
  • 用途:DApp 查状态(如 balanceOf、getPrice)。
  • 与真实交易的区别:不发链、不消耗 Gas、不进区块。

原理流程

  1. DApp 发 eth_call 请求:to = 合约地址,data = 编码的函数调用。
  2. 节点在 EVM 里创建临时执行上下文(当前状态)。
  3. 执行合约代码(可以 SLOAD、可以读存储)。
  4. 执行结束后,回滚状态(所有 SSTORE 都撤销)。
  5. 返回执行结果(返回值),不消耗 Gas。

代码或图示

eth_call 原理:

  真实交易:
    1. 签名交易 → 发交易池
    2. 验证者打包 → 进区块
    3. EVM 执行 → 修改状态
    4. 消耗 Gas

  eth_call:
    1. DApp 发请求(to, data)
    2. 节点在 EVM 里执行(临时上下文)
    3. 执行结束 → 回滚状态
    4. 返回结果(不消耗 Gas)

  用途:
    DApp 查 balanceOf、getPrice、查询合约状态

常见误区

  • 误区:eth_call 会修改状态;正解:eth_call 执行后回滚状态,不修改。
  • 误区:eth_call 消耗 Gas;正解:eth_call 不消耗 Gas(节点免费提供)。
  • 误区:eth_call 与真实交易一样;正解:eth_call 只是模拟,不进区块。

追问

  • eth_call 能调用写函数吗?答:技术上能,但执行后回滚状态,没有实际效果;通常 eth_call 只调用 view/pure 函数。机制上节点允许任何调用,但状态回滚。边界在于:有些节点可能限制写函数调用。延伸:这是 DApp 查状态的方式。
  • eth_call 的状态是哪个?答:默认是最新状态("latest"),也可以指定区块号(如"0x1000000");指定历史区块号需要 archive 节点。机制上 eth_call 在指定区块的状态上执行。边界在于:历史状态查询需要 archive 节点。延伸:这是 15.3.5-001 的主题。
  • eth_call 与真实交易的 Gas 估算有什么关系?答:eth_call 可以用来估算真实交易的 Gas(eth_estimateGas);节点在 EVM 里跑一遍,返回消耗的 Gas。机制上 eth_estimateGas 就是带 Gas 计算的 eth_call。边界在于:估算值可能与实际有偏差(因为状态变化)。延伸:这是钱包估算 Gas 的方式。

15.3.5-005 eth_getLogs 为什么有区块范围限制?

一句话结论

eth_getLogs 查事件日志时,托管 RPC 限制区块范围(如一次最多 1000 块),因为扫描大量区块的日志很耗资源;如果不限制,恶意用户可以让节点扫几万块,耗尽节点资源。

概念解释

  • eth_getLogs:查事件日志,按区块范围与 topic 过滤。
  • 区块范围限制:托管 RPC 限制一次最多查多少块(如 1000 块)。
  • 为什么:扫描大量区块日志很耗资源,不限制会被 DoS。
  • 替代:用 The Graph 之类的索引服务查历史日志。

原理流程

  1. DApp 发 eth_getLogs 请求:fromBlock、toBlock、topics。
  2. 节点扫描 fromBlock 到 toBlock 的所有收据,过滤匹配的日志。
  3. 如果范围太大(如 10 万块),扫描很耗资源。
  4. 托管 RPC 限制范围(如最多 1000 块),防止 DoS。
  5. DApp 要查历史日志,用 The Graph 之类的索引服务。

代码或图示

eth_getLogs 限制:

  托管 RPC(如 Infura):
    一次最多查 1000 块
    否则报错:"query exceeds max block range"

  例:
    查从区块 100 万到 101 万的日志:
      范围 = 1 万块 → 超限,报错

    正确做法:
      分批查:100 万-101 万分成 10 批,每批 1000 块
      或用 The Graph subgraph

  自建节点:
    可以配置更大范围(但要注意节点资源)

常见误区

  • 误区:eth_getLogs 可以查任意范围;正解:托管 RPC 有区块范围限制。
  • 误区:eth_getLogs 很快;正解:扫描大量区块日志很耗资源。
  • 误区:The Graph 是必须的;正解:小范围查询 eth_getLogs 即可,大范围查询用 The Graph。

追问

  • 为什么扫描日志很耗资源?答:因为日志在每个区块的收据里,要扫描所有区块的收据,过滤匹配的日志。机制上节点要遍历每个区块的 receipts MPT。边界在于:区块越多,扫描越慢。延伸:这就是 The Graph 存在的原因。
  • 怎么查大量历史日志?答:用 The Graph subgraph——它把事件日志索引成数据库,DApp 直接查数据库,不用扫描区块。机制上 The Graph 节点持续监听事件日志,写入数据库。边界在于:The Graph 有索引延迟(几分钟到几小时)。延伸:这是 15.3.5-008 的主题。
  • 自建节点可以放宽限制吗?答:可以,自建节点可以配置更大范围;但要注意节点资源(CPU、磁盘)。机制上自建节点没有托管限制。边界在于:这也是为什么大型团队自建节点。延伸:这是节点运维的权衡。

15.3.5-006 交易池(mempool)是什么?

一句话结论

交易池(mempool)是节点收到的、尚未被打包进区块的交易临时存储;节点从 P2P 网络收到交易后先放进 mempool,等待验证者打包。

概念解释

  • mempool:交易池,临时存储未打包的交易。
  • 交易广播:节点收到交易后,广播给其他节点(P2P 网络)。
  • 交易顺序:mempool 里的交易按 Gas 价格排序,高 Gas 优先打包。
  • 交易过期:mempool 里的交易如果太久没被打包,会被丢弃。

原理流程

  1. 用户签名交易,发 RPC 节点(或 P2P 网络)。
  2. 节点验证交易(签名、nonce、余额),通过后放进 mempool。
  3. 节点广播交易给其他节点(P2P 网络)。
  4. 验证者打包区块时,从 mempool 选交易(按 Gas 价格排序)。
  5. 交易被打包后,从 mempool 移除。

代码或图示

交易池流程:

  用户签名交易
    ↓
  发 RPC 节点(或 P2P)
    ↓
  节点验证(签名、nonce、余额)
    ↓
  放进 mempool(临时存储)
    ↓
  节点广播给其他节点(P2P)
    ↓
  验证者打包区块时,从 mempool 选交易(按 Gas 排序)
    ↓
  交易被打包 → 从 mempool 移除

  例:
    高 Gas 交易优先打包
    低 Gas 交易可能等很久

常见误区

  • 误区:交易发 RPC 节点就直接进区块;正解:交易先进 mempool,等待验证者打包。
  • 误区:mempool 是全局的;正解:每个节点有自己的 mempool,不是全局共享。
  • 误区:mempool 里的交易一定会被打包;正解:交易可能因为 Gas 太低、nonce 过期、或被替换而不打包。

追问

  • 怎么监听 mempool?答:用 WebSocket 订阅 newPendingTransactions,节点会推送新交易。机制上节点收到新交易时通知订阅者。边界在于:托管 RPC 可能不支持订阅 mempool。延伸:这是 MEV 搜索者的工作方式。
  • 交易被替换(replacement)是什么?答:用户发了一笔交易后,又发了一笔同 nonce 但更高 Gas 的交易,节点用新交易替换 mempool 里的旧交易。机制上 nonce 相同的交易会替换。边界在于:这也是"加速交易"的方式。延伸:这是 DApp 交易体验的一部分。
  • mempool 为什么会被清空?答:节点重启、或交易过期(太久没被打包),mempool 会清空。机制上 mempool 是易失的,不持久化。边界在于:这也是为什么用户要保存交易哈希(如果交易没进区块,要重发)。延伸:这是 DApp 交易可靠性的重点。

15.3.5-007 节点同步模式有哪些?

一句话结论

节点同步模式包括:full sync(逐区块执行,慢但完整)、snap sync(从快照同步状态,快)、fast sync(快速同步到最新,再切换 full)。选择取决于时间与磁盘需求。

概念解释

  • full sync:逐区块执行所有交易,慢但完整,可以验证所有历史。
  • snap sync:从可信快照同步最新状态,快,但不验证历史。
  • fast sync:快速同步到最新区块头,再切换 full sync。
  • 选择:full sync 慢但可信,snap sync 快但不验证历史。

原理流程

  1. full sync:从创世块开始,逐区块执行所有交易,构建状态树。
  2. snap sync:从其他节点下载最新状态快照,跳过历史执行。
  3. fast sync:快速同步到最新区块头,再切换 full sync 执行后续区块。
  4. 选择:full sync 慢(几周)但完整,snap sync 快(几小时)但不验证历史。
  5. 大多数节点用 snap sync 快速启动。

代码或图示

同步模式:

  full sync:
    从创世块开始,逐区块执行所有交易
    时间:几周
    优点:完整验证历史
    缺点:慢

  snap sync:
    从可信快照下载最新状态
    时间:几小时
    优点:快
    缺点:不验证历史

  fast sync:
    快速同步到最新区块头,再切换 full sync
    时间:几天
    优点:折中

  选择:
    大多数节点用 snap sync 快速启动
    归档节点用 full sync 保留历史

常见误区

  • 误区:所有节点都用 full sync;正解:大多数节点用 snap sync 快速启动。
  • 误区:snap sync 不安全;正解:snap sync 从可信快照同步,信任快照来源。
  • 误区:同步模式影响共识;正解:同步模式只影响节点启动速度,共识一致。

追问

  • 为什么要有 snap sync?答:因为 full sync 太慢(几周),普通用户等不起;snap sync 从快照同步,几小时就能启动。机制上 snap sync 跳过历史执行,直接下载最新状态。边界在于:snap sync 不验证历史,信任快照来源。延伸:这是节点可用性的优化。
  • snap sync 信任什么?答:信任快照来源(其他节点、官方快照);如果快照是恶意的,节点会同步错误状态。机制上 snap sync 不验证历史,依赖快照来源可信。边界在于:这也是为什么大多数节点从官方或可信来源下载快照。延伸:这是去中心化的权衡。
  • 归档节点用什么同步?答:归档节点通常用 full sync(或 Erigon 的 staged sync),保留所有历史状态。机制上归档节点要完整执行历史,构建状态树。边界在于:归档节点同步时间长(几周)。延伸:这是 15.3.5-001 的主题。

15.3.5-008 The Graph subgraph 是怎么索引的?

一句话结论

The Graph subgraph 是一个索引服务:它持续监听事件日志,把事件数据索引成数据库;DApp 直接查数据库,不用扫描区块。原理是:定义要索引哪些事件(subgraph manifest),The Graph 节点持续同步事件日志,写入数据库,DApp 用 GraphQL 查询。

概念解释

  • subgraph:The Graph 的索引定义,指定要索引哪些合约、哪些事件。
  • The Graph 节点:持续监听事件日志,写入数据库。
  • GraphQL:DApp 查询语言,直接查数据库。
  • 索引延迟:The Graph 同步事件有延迟(几分钟到几小时)。

原理流程

  1. 定义 subgraph manifest:指定合约地址、事件、要提取的字段。
  2. The Graph 节点持续同步区块,监听指定事件。
  3. 事件触发时,节点把数据写入数据库。
  4. DApp 用 GraphQL 查询数据库,不用扫描区块。
  5. 索引延迟:几分钟到几小时(取决于 The Graph 网络)。

代码或图示

The Graph subgraph 原理:

  定义 subgraph:
    合约地址:0xToken...
    事件:Transfer(address,address,uint256)
    字段:from, to, value

  The Graph 节点:
    持续同步区块
    监听 Transfer 事件
    事件触发时 → 写入数据库

  DApp 查询:
    GraphQL 查询:
      {
        transfers(where: {to: "0xBob..."}) {
          from
          to
          value
        }
      }

  优点:
    不用扫描区块,直接查数据库
    支持复杂查询(过滤、排序、分页)

  缺点:
    索引延迟(几分钟到几小时)

常见误区

  • 误区:The Graph 是实时的;正解:The Graph 有索引延迟(几分钟到几小时)。
  • 误区:The Graph 是必须的;正解:小范围查询 eth_getLogs 即可,大范围用 The Graph。
  • 误区:The Graph 是中心化的;正解:The Graph 是去中心化网络(节点激励),也有托管服务。

追问

  • The Graph 为什么有索引延迟?答:因为 The Graph 节点要持续同步区块,监听事件,写入数据库;这个过程需要时间。机制上节点不是实时同步,而是按区块批量处理。边界在于:实时性要求高的 DApp 直接用 WebSocket 订阅事件。延伸:这是索引服务的权衡。
  • The Graph 与自建索引有什么区别?答:自建索引(自己跑节点、写数据库)实时性更高,但运维成本高;The Graph 是托管服务,成本低但有延迟。机制上两者原理相同,都是索引事件日志。边界在于:大型团队自建索引,小团队用 The Graph。延伸:这是 DApp 架构的选择。
  • The Graph 的去中心化是什么?答:The Graph 网络由索引节点组成,节点质押 GRT 代币提供索引服务;查询者付费用 GRT。机制上节点激励去中心化索引。边界在于:也有托管服务(The Graph 官方托管),更简单。延伸:这是 Web3 基础设施的趋势。

15.3.5-009 自建 RPC 节点 vs 托管 RPC 怎么选?

一句话结论

自建 RPC 节点成本高(硬件、运维、带宽),但可控、无限流;托管 RPC(如 Infura、Alchemy)成本低、上手快,但有限流。选择取决于团队规模、性能需求、预算。

概念解释

  • 自建节点:自己跑 Geth/reth,自己运维。
  • 托管 RPC:用 Infura、Alchemy、QuickNode 等服务。
  • 自建优点:可控、无限流、数据私有。
  • 托管优点:成本低、上手快、不用运维。

原理流程

  1. 自建节点:买服务器、跑节点、运维、监控。
  2. 托管 RPC:注册账号、拿 API Key、直接用。
  3. 自建成本:硬件(几千到几万/月)、带宽、运维人力。
  4. 托管成本:按 tier 付费(免费 tier 有限流,付费 tier 更宽松)。
  5. 选择:小团队用托管,大团队自建。

代码或图示

自建 vs 托管 RPC:

  自建节点:
    优点:可控、无限流、数据私有
    缺点:成本高、运维复杂
    适合:大团队、高流量 DApp

  托管 RPC:
    优点:成本低、上手快、不用运维
    缺点:有限流、数据共享
    适合:小团队、早期 DApp

  成本对比:
    自建:服务器 $500-2000/月 + 带宽 + 运维人力
    托管:免费 tier 或 $100-1000/月(付费 tier)

常见误区

  • 误区:所有 DApp 都要自建节点;正解:小团队用托管即可。
  • 误区:托管 RPC 不安全;正解:托管 RPC 只是查节点,不存私钥(私钥在用户钱包里)。
  • 误区:自建节点性能更好;正解:自建与托管性能取决于节点配置。

追问

  • 什么时候要自建节点?答:当流量大、需要无限流、需要私有数据、或需要 archive 节点时。机制上托管 RPC 有流量限制,大流量 DApp 成本高。边界在于:自建节点运维成本高。延伸:这是团队规模与成本的权衡。
  • 托管 RPC 有什么风险?答:托管 RPC 可能宕机、限流、或被攻击;DApp 要设计降级方案(如备用 RPC)。机制上托管 RPC 是共享服务,要容错。边界在于:DApp 前端应该支持多 RPC 切换。延伸:这是 DApp 可靠性的重点。
  • 怎么提高 RPC 可靠性?答:用多 RPC(主 RPC + 备用 RPC)、缓存常用查询、批量请求。机制上多 RPC 容错,缓存减少请求。边界在于:这增加了前端复杂度。延伸:这是 DApp 性能优化的一部分。

15.3.5-010 节点的状态缓存层有什么用?

一句话结论

节点的状态缓存层(如 Geth 的 state cache、reth 的缓存)缓存最近访问的 MPT 节点,避免每次 SLOAD 都从磁盘读;大幅提高 RPC 请求的响应速度。

概念解释

  • 状态缓存:缓存最近访问的 MPT 节点(账户、存储槽)。
  • 为什么:MPT 节点存在磁盘上,每次 SLOAD 都从磁盘读很慢;缓存避免磁盘 IO。
  • 缓存大小:几百 MB 到几 GB,取决于节点配置。
  • 效果:RPC 请求响应速度提升数倍。

原理流程

  1. 节点收到 RPC 请求(如 eth_call)。
  2. 执行时要 SLOAD 某槽位。
  3. 先查缓存:如果缓存里有,直接用;否则从磁盘读 MPT 节点。
  4. 读完后放进缓存(LRU 淘汰)。
  5. 热数据(常用账户、槽位)一直在缓存里,RPC 请求快。

代码或图示

状态缓存原理:

  无缓存:
    SLOAD → 从磁盘读 MPT 节点 → 慢(几 ms 到几十 ms)

  有缓存:
    SLOAD → 查缓存 → 命中 → 快(几 μs)
         → 未命中 → 从磁盘读 → 放进缓存

  缓存大小:
    Geth:默认几百 MB(可配置)
    reth:优化的缓存,内存占用更少

  效果:
    热数据(常用账户、槽位)在缓存里
    RPC 请求响应速度提升数倍

常见误区

  • 误区:节点不需要缓存;正解:缓存大幅提升 RPC 性能。
  • 误区:缓存是磁盘缓存;正解:缓存是内存缓存(RAM)。
  • 误区:缓存越大越好;正解:缓存太大占用内存,影响其他进程。

追问

  • 缓存是怎么淘汰的?答:用 LRU(Least Recently Used)算法——最近最少使用的节点被淘汰。机制上缓存满时,淘汰最久没访问的节点。边界在于:热点数据一直在缓存里,冷数据被淘汰。延伸:这是经典缓存设计。
  • 缓存与一致性有什么关系?答:缓存是只读的,修改状态时(SSTORE)同时更新缓存;区块切换时,缓存回滚到旧状态。机制上缓存是状态的快照,与区块一致。边界在于:重org 时缓存要重建。延伸:这是节点一致性的保证。
  • 怎么调优缓存?答:根据节点配置(CPU、内存)调整缓存大小;大内存节点可以配更大缓存。机制上缓存越大,热数据命中率越高。边界在于:缓存太大占用内存,影响其他进程。延伸:这是节点运维的调优。

动手练习

练习 1:用 JSON-RPC 查一笔交易

  • 任务:用 curl 或 Postman 调用托管 RPC(如 Infura),查最新区块号、查某地址余额、模拟调用合约函数。
  • 验收标准:
    1. 能写出 eth_blockNumber、eth_getBalance、eth_call 的请求。
    2. 能解释 eth_call 与真实交易的区别。
    3. 能说出托管 RPC 的限流限制。

练习 2:写一个简单的 subgraph

  • 任务:用 The Graph 托管服务,写一个 subgraph 索引 ERC20 的 Transfer 事件;用 GraphQL 查询。
  • 验收标准:
    1. 能写出 subgraph manifest(合约地址、事件)。
    2. 能解释索引延迟的原因。
    3. 能写出 GraphQL 查询语句。

自检清单

  • [ ] 能区分 full 节点与 archive 节点的用途与成本?
  • [ ] 能说出 Geth 与 reth 的区别?
  • [ ] 能列出常用 JSON-RPC 方法?
  • [ ] 能解释 eth_call 的模拟原理?
  • [ ] 能说明 eth_getLogs 的区块范围限制?
  • [ ] 能解释 mempool 的工作流程?
  • [ ] 能区分 full sync、snap sync、fast sync?
  • [ ] 能解释 The Graph subgraph 的索引原理?
  • [ ] 能对比自建 RPC 与托管 RPC 的选择?
  • [ ] 能说明状态缓存层的作用?

延伸阅读

  • Geth 官方文档:JSON-RPC API、同步模式。
  • reth 官方文档:Rust 以太坊客户端。
  • The Graph 官方文档:subgraph 开发。
  • Ethereum 文档:Nodes and Clients。
  • 《Mastering Ethereum》:客户端与 RPC 章节。

待整理清单

  • [ ] 补充主流托管 RPC(Infura、Alchemy、QuickNode)的限流参数对比
  • [ ] 补充自建节点的硬件配置与带宽预算
  • [ ] 补充 The Graph 去中心化网络的当前状态(待确认)