15.6.2 链上数据读取与索引
所属:全栈开发面试题库 / [15 Web3 与区块链((../index.md) / [15.6 DApp 全栈与钱包((index.md)
本节要解决的问题
面试里讲"链上数据",多数人只会说"用 eth_call 读合约"。真正的分水岭是:能不能讲清为什么不能直接 eth_getLogs 全量扫描、The Graph subgraph 的索引原理、RPC 限流的应对、以及区块重组时索引数据怎么处理。本节解决四个具体问题:一是把 eth_call 与 eth_getLogs 的差异讲透——前者是单次状态查询,后者是历史事件扫描,全量扫描会被 RPC 节点拒绝;二是讲清 The Graph subgraph 的索引原理——从合约事件到 GraphQL 查询的完整链路;三是把 RPC 限流的应对(multicall、批量查询、自建节点)讲透;四是落到区块重组(reorg)时索引数据怎么处理——回滚到旧状态、重新索引。
学习目标
学完本节,你应当能够:
- 比较
eth_call与eth_getLogs的差异与使用场景。 - 描述 The Graph subgraph 的索引原理与 schema 设计。
- 用 multicall 批量查询合约状态。
- 处理区块重组时的索引回滚。
先修与前置
- 建议先读 [15.3.5 节点客户端、RPC 与索引((../../15.3-以太坊与EVM/15.3.5-节点客户端RPC与索引.md),理解 RPC 基础。
- 本节是 [15.6.3 交易发送与用户体验((15.6.3-交易发送与用户体验.md) 的前置,先掌握数据读取再学交易发送。
知识地图
数据读取路径
DApp 前端 → RPC 节点(Infura/Alchemy/自建)
├─ eth_call → 单次状态查询(如 balanceOf)
├─ eth_getLogs → 历史事件扫描(如 Transfer 事件)
└─ eth_blockNumber → 当前区块号
The Graph subgraph
合约事件 → subgraph 索引器 → GraphQL 查询
Schema 定义 → 实体映射 → 事件处理器
RPC 限流应对
1. multicall(一次调用查多个合约)
2. 批量查询(一次请求多个 eth_call)
3. 自建节点(无限制)
核心术语
- eth_call:单次状态查询,调用合约只读函数。
- eth_getLogs:历史事件扫描,按事件 topic 过滤。
- The Graph:链上数据索引协议,subgraph 是索引项目。
- multicall:一次调用查多个合约状态,减少 RPC 次数。
- archive node:保存所有历史状态的节点,full node 只保存最新状态。
- 区块重组(Reorg):链分叉后,旧区块被替换,索引要回滚。
覆盖范围
- eth_call 与 eth_getLogs 的差异与使用场景
- The Graph subgraph 的索引原理与 schema 设计
- RPC 限流与 multicall 批量查询
- 事件订阅(websocket)与轮询的选型
- 区块重组时的索引回滚
- archive node vs full node 的取舍
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 15.6.2-001 | eth_call vs eth_getLogs 区别? | 基础 | ★★★★★ |
| 15.6.2-002 | The Graph subgraph 是什么?为什么不能直接 eth_getLogs 全量? | 基础 | ★★★★★ |
| 15.6.2-003 | RPC 限流怎么产生?免费 RPC 节点的真实限制? | 基础 | ★★★★ |
| 15.6.2-004 | 批量查询(eth_call aggregate / multicall)怎么写? | 进阶 | ★★★★ |
| 15.6.2-005 | subgraph 的 schema 设计与索引延迟怎么权衡? | 进阶 | ★★★★ |
| 15.6.2-006 | 事件订阅(websocket logs)与轮询如何选型? | 进阶 | ★★★ |
| 15.6.2-007 | 区块重组(reorg)时索引数据怎么处理? | 进阶 | ★★★ |
| 15.6.2-008 | 为什么 archive node 贵?什么时候必须用 archive node? | 高级 | ★★★ |
| 15.6.2-009 | 设计一个 DApp 前端的余额/持仓列表,调用链怎么走? | 高级 | ★★★★ |
| 15.6.2-010 | 自建节点 vs 第三方 RPC(Infura/Alchemy)的取舍? | 高级 | ★★★ |
15.6.2-001 eth_call vs eth_getLogs 区别?
一句话结论
eth_call 是单次状态查询,调用合约只读函数(如 balanceOf);eth_getLogs 是历史事件扫描,按事件 topic 过滤(如 Transfer 事件)。前者查当前状态,后者查历史事件。
概念解释
- eth_call:调用合约只读函数,返回当前状态。
- eth_getLogs:扫描历史事件日志,按 topic 过滤。
- 前者:查当前余额、当前供应量。
- 后者:查历史转账记录、历史事件。
原理流程
- DApp 要查用户余额:调用
eth_call,参数是balanceOf(address)。 - DApp 要查历史转账:调用
eth_getLogs,参数是Transfer事件 topic。 eth_call返回当前状态,eth_getLogs返回历史事件列表。
代码或图示
// eth_call:查余额
const balance = await provider.request({
method: 'eth_call',
params: [{
to: '0xTokenAddress',
data: '0x70a08231000000000000000000000000UserAddress' // balanceOf(address)
}(
});
// eth_getLogs:查历史转账
const logs = await provider.request({
method: 'eth_getLogs',
params: [{
address: '0xTokenAddress',
topics: [
'0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef' // Transfer event
(,
fromBlock: '0x1000000',
toBlock: 'latest'
}(
});
常见误区
- 误区:eth_call 可以查历史;正解:它只查当前状态。
- 误区:eth_getLogs 可以查任意范围;正解:RPC 节点限制区块范围(如 10000 块)。
- 误区:两者等价;正解:eth_call 查状态,eth_getLogs 查事件。
追问
- eth_call 为什么只查当前状态?答:因为它在最新区块上执行。机制上 eth_call 调用合约只读函数,在最新状态上执行。边界在于:如果要查历史状态,需要 archive node。延伸:archive node 保存所有历史状态。
- eth_getLogs 为什么限制区块范围?答:因为全量扫描消耗资源。机制上 RPC 节点限制
fromBlock到toBlock的范围(如 10000 块)。边界在于:超过范围返回错误。延伸:很多项目用 subgraph 索引历史事件。 - 什么时候用 eth_call vs eth_getLogs?答:查当前状态用 eth_call,查历史事件用 eth_getLogs。机制上前者查余额,后者查转账记录。边界在于:有些数据两者都能查(如余额历史),需要选型。延伸:很多 DApp 用 eth_call 查当前,subgraph 查历史。
15.6.2-002 The Graph subgraph 是什么?为什么不能直接 eth_getLogs 全量?
一句话结论
The Graph subgraph 是链上数据索引项目,把合约事件索引成 GraphQL 查询接口。不能直接 eth_getLogs 全量扫描,因为 RPC 节点限制区块范围、全量扫描消耗资源、且 DApp 需要聚合查询(如"用户的所有持仓")。
概念解释
- subgraph:索引项目,从合约事件到 GraphQL 查询。
- 不能全量 eth_getLogs:RPC 节点限制范围、消耗资源。
- 聚合查询:DApp 需要"用户的所有持仓",需要跨多个合约聚合。
原理流程
- 合约事件触发(如
Transfer)。 - subgraph 索引器监听事件,处理事件(更新实体)。
- subgraph 存储实体到数据库。
- DApp 用 GraphQL 查询 subgraph,获取聚合数据。
代码或图示
# subgraph schema
type Transfer @entity {
id: ID!
from: Bytes!
to: Bytes!
amount: BigInt!
blockNumber: BigInt!
}
# DApp 查询
query {
transfers(where: { to: "0xUserAddress" }, first: 10) {
amount
blockNumber
}
}
常见误区
- 误区:subgraph 是数据库;正解:它是索引器,把链上事件索引成 GraphQL。
- 误区:subgraph 实时;正解:它有索引延迟(几秒到几分钟)。
- 误区:subgraph 是必须的;正解:简单 DApp 可以直接 eth_call。
追问
- subgraph 的索引延迟?答:几秒到几分钟。机制上 subgraph 索引器监听新区块,处理事件,写入数据库。边界在于:新区块确认后,subgraph 才能索引。延伸:很多 DApp 接受几秒延迟。
- subgraph 怎么设计?答:定义 schema、实体映射、事件处理器。机制上开发者写 GraphQL schema,定义实体;写映射,把事件映射到实体;写处理器,处理事件。边界在于:schema 设计影响查询性能。延伸:很多项目用 The Graph 托管服务。
- 为什么不能直接 eth_getLogs 全量?答:RPC 节点限制范围。机制上 eth_getLogs 限制
fromBlock到toBlock的范围(如 10000 块)。边界在于:全量扫描需要多次调用,效率低。延伸:很多项目用 subgraph 索引历史事件。
15.6.2-003 RPC 限流怎么产生?免费 RPC 节点的真实限制?
一句话结论
RPC 限流是因为免费节点资源有限,限制每秒请求数(RPM)与每天请求数。免费节点(Infura/Alchemy)通常限制 100K 次/天,超过返回错误。
概念解释
- 限流:限制每秒请求数(RPM)。
- 免费节点:Infura/Alchemy 免费额度,100K 次/天。
- 超限:返回
429 Too Many Requests错误。
原理流程
- DApp 调用 RPC 节点,消耗配额。
- 超过限额(如 100K 次/天),返回
429错误。 - DApp 需要等待或升级付费。
代码或图示
免费 RPC 限制:
Infura:100K 次/天
Alchemy:100M 次/天(免费额度)
超过限制:429 Too Many Requests
常见误区
- 误区:免费节点无限用;正解:有配额限制。
- 误区:限流只影响高频请求;正解:批量请求也消耗配额。
- 误区:付费节点无限用;正解:付费也有配额,只是更大。
追问
- 怎么应对限流?答:用 multicall 批量查询、缓存结果、自建节点。机制上 multicall 一次调用查多个合约,减少 RPC 次数;缓存结果避免重复查询;自建节点无限制。边界在于:自建节点成本高。延伸:很多项目用第三方 RPC + 缓存。
- 限流错误怎么处理?答:等待重试、降级到缓存。机制上收到
429错误,等待几秒后重试;如果频繁限流,降级到缓存数据。边界在于:用户体验差(loading 状态)。延伸:很多 DApp 显示"数据加载中"。 - 付费节点的配额?答:更大。机制上 Infura 付费额度 1M 次/天,Alchemy 付费额度 1B 次/天。边界在于:付费也贵。延伸:很多项目在用户量大时自建节点。
15.6.2-004 批量查询(eth_call aggregate / multicall)怎么写?
一句话结论
multicall 是一次调用查多个合约状态,减少 RPC 次数。用 Multicall 合约,把多个 eth_call 打包成一次调用。
概念解释
- multicall:一次调用查多个合约状态。
- Multicall 合约:部署在链上,接收多个调用,返回结果。
- 减少 RPC 次数:从 N 次降到 1 次。
原理流程
- DApp 要查多个合约状态(如多个代币余额)。
- 构造多个调用
{ target, callData }。 - 调用 Multicall 合约
aggregate(calls)。 - Multicall 合约执行所有调用,返回结果数组。
代码或图示
// Multicall
const multicall = new ethers.Contract(
'0xMulticallAddress',
['function aggregate(tuple(address target, bytes callData)[( calls) view returns (uint256 blockNumber, bytes[( returnData)'(,
provider
);
// 构造调用
const calls = [
{ target: '0xToken1', callData: '0x70a08231...' }, // balanceOf(User1)
{ target: '0xToken2', callData: '0x70a08231...' }, // balanceOf(User2)
(;
// 一次调用
const [blockNumber, returnData( = await multicall.aggregate(calls);
常见误区
- 误区:multicall 是免费的;正解:它消耗一次 RPC 调用 + 链上 gas。
- 误区:multicall 可以查任意数量;正解:受 gas 限制,通常 100 次以内。
- 误区:multicall 返回结果顺序一致;正解:它按调用顺序返回。
追问
- multicall 为什么减少 RPC 次数?答:因为一次调用查多个合约。机制上 N 次 eth_call 变成 1 次 multicall。边界在于:multicall 内部执行 N 次调用,gas 消耗大。延伸:很多项目用 multicall 查多个代币余额。
- multicall 怎么处理失败?答:用
tryAggregate。机制上aggregate任何调用失败就 revert;tryAggregate返回{ success, returnData },失败不影响其他。边界在于:tryAggregate返回success标志,DApp 要处理失败。延伸:很多项目用tryAggregate。 - multicall 适合什么场景?答:查多个合约状态。机制上 DApp 查用户的多个代币余额,用 multicall 一次查完。边界在于:如果只查一个合约,multicall 反而慢。延伸:很多 DApp 用 multicall 查余额列表。
15.6.2-005 subgraph 的 schema 设计与索引延迟怎么权衡?
一句话结论
schema 设计影响查询性能与索引延迟:实体越多、关系越复杂,索引越慢,但查询越灵活。需要在"查询需求"与"索引延迟"之间权衡。
概念解释
- schema:定义实体与关系。
- 索引延迟:新区块到 subgraph 可查询的时间。
- 权衡:实体越多、关系越复杂,索引越慢。
原理流程
- DApp 需要查"用户的所有持仓"。
- schema 设计
User、Position实体,关系User.positions。 - 索引器处理事件,更新实体。
- DApp 查询
User.positions。
代码或图示
# 简单 schema
type User @entity {
id: ID!
positions: [Position!(! @derivedFrom(field: "user")
}
type Position @entity {
id: ID!
user: User!
amount: BigInt!
}
常见误区
- 误区:schema 越复杂越好;正解:复杂 schema 索引慢。
- 误区:索引延迟不重要;正解:用户体验差。
- 误区:schema 设计一次定终身;正解:可以迁移,但成本高。
追问
- schema 怎么设计?答:按查询需求。机制上 DApp 查什么,schema 就设计什么。边界在于:过度设计(用不到的实体)索引慢。延伸:很多项目先简单,后迭代。
- 索引延迟怎么优化?答:减少实体、简化关系。机制上索引器处理每个事件,更新实体;实体越少,处理越快。边界在于:简化 schema 可能不满足查询需求。延伸:很多项目接受几秒延迟。
- schema 迁移怎么处理?答:重新部署 subgraph。机制上 schema 变更后,重新部署 subgraph,重新索引。边界在于:重新索引耗时。延伸:很多项目用 The Graph 托管服务,自动处理。
15.6.2-006 事件订阅(websocket logs)与轮询如何选型?
一句话结论
事件订阅(websocket)实时推送,轮询定期查询。需要实时性用 websocket,容忍延迟用轮询。
概念解释
- websocket:实时推送事件。
- 轮询:定期查询(如每 5 秒)。
- 实时性:websocket 即时,轮询有延迟。
原理流程
- DApp 需要实时更新(如交易确认)。
- 用 websocket 订阅事件,节点实时推送。
- 或轮询,定期查
eth_blockNumber。
代码或图示
// websocket 订阅
const ws = new WebSocket('wss://polygon-rpc.com');
ws.onopen = () => {
ws.send(JSON.stringify({
method: 'eth_subscribe',
params: ['logs', { address: '0xTokenAddress' }(
}));
};
ws.onmessage = (event) => {
console.log('New log:', JSON.parse(event.data));
};
// 轮询
setInterval(async () => {
const blockNumber = await provider.getBlockNumber();
console.log('Current block:', blockNumber);
}, 5000);
常见误区
- 误区:websocket 总是更好;正解:它维护成本高,轮询简单。
- 误区:轮询延迟高;正解:5 秒轮询通常可接受。
- 误区:websocket 免费;正解:付费节点才支持 websocket。
追问
- websocket 怎么维护?答:重连、心跳。机制上 websocket 连接可能断开,需要自动重连;定期心跳保持连接。边界在于:维护成本高。延伸:很多项目用轮询,简单可靠。
- 轮询间隔怎么定?答:按需求。机制上交易确认需要实时(1 秒),余额查询可以 30 秒。边界在于:太频繁消耗配额。延伸:很多项目用 5 秒轮询。
- 什么时候用 websocket?答:实时需求。机制上交易确认、价格更新需要实时。边界在于:websocket 付费。延伸:很多 DApp 用轮询,接受延迟。
15.6.2-007 区块重组(reorg)时索引数据怎么处理?
一句话结论
区块重组时,旧区块被替换,索引要回滚到重组前的状态,重新索引新区块。
概念解释
- reorg:链分叉后,旧区块被替换。
- 索引回滚:删除旧区块的索引数据,重新索引新区块。
- 延迟确认:等待多个区块确认后再索引。
原理流程
- 链分叉,区块 N 被替换成区块 N'。
- subgraph 索引到旧区块 N。
- 检测到 reorg,回滚到区块 N-1。
- 重新索引新区块 N'。
代码或图示
reorg 流程:
Block N → 被替换成 Block N'
subgraph 回滚到 Block N-1
重新索引 Block N'
常见误区
- 误区:reorg 很少见;正解:PoW 链偶发,PoS 链罕见。
- 误区:索引后就不用管;正解:reorg 要回滚。
- 误区:等待确认没用;正解:等待 N 个确认(如 6 个)减少 reorg。
追问
- reorg 怎么检测?答:比较新区块与旧区块。机制上 subgraph 定期检查新区块,如果与索引的不同,检测到 reorg。边界在于:reorg 可能延迟检测。延伸:很多项目等待 N 个确认后再索引。
- reorg 怎么回滚?答:删除旧区块的索引数据。机制上 subgraph 回滚到重组前的状态,重新索引。边界在于:回滚复杂,需要维护历史状态。延伸:The Graph 自动处理 reorg。
- 等待多少个确认?答:通常 6 个(PoW)。机制上 PoW 链 reorg 概率随确认数指数下降,6 个确认后几乎不可能。边界在于:PoS 链 reorg 罕见,1-2 个确认即可。延伸:很多 DApp 等待 6 个确认。
15.6.2-008 为什么 archive node 贵?什么时候必须用 archive node?
一句话结论
archive node 保存所有历史状态,磁盘占用大(TB 级),所以贵。需要查历史状态(如"3 个月前的余额")时必须用 archive node。
概念解释
- archive node:保存所有历史状态。
- full node:只保存最新状态。
- 磁盘占用:archive node TB 级,full node 几百 GB。
原理流程
- full node 只保存最新状态(如最新余额)。
- archive node 保存所有历史状态(如"3 个月前的余额")。
- 查历史状态必须用 archive node。
代码或图示
archive vs full:
full node:几百 GB,只保存最新状态
archive node:TB 级,保存所有历史状态
常见误区
- 误区:full node 可以查历史;正解:它只保存最新状态。
- 误区:archive node 便宜;正解:磁盘成本高。
- 误区:必须用 archive node;正解:大多数 DApp 用 full node。
追问
- archive node 为什么贵?答:磁盘占用大。机制上 archive node 保存所有历史状态,TB 级磁盘。边界在于:磁盘成本高,运行成本高。延伸:很多项目用第三方 archive node(Alchemy/Infura)。
- 什么时候必须用 archive node?答:查历史状态。机制上 DApp 查"3 个月前的余额",必须用 archive node。边界在于:大多数 DApp 只查当前状态,用 full node。延伸:很多项目用 subgraph 索引历史。
- 自建 archive node 成本?答:高。机制上需要 TB 级磁盘、高带宽。边界在于:自建成本远高于第三方。延伸:很多项目用第三方 archive node。
15.6.2-009 设计一个 DApp 前端的余额/持仓列表,调用链怎么走?
一句话结论
调用链:前端用 multicall 一次查多个代币余额,用 subgraph 查历史持仓,缓存结果减少 RPC 次数。
概念解释
- multicall:查多个代币余额。
- subgraph:查历史持仓。
- 缓存:减少 RPC 次数。
原理流程
- 用户访问 DApp,前端请求余额列表。
- 用 multicall 一次查多个代币余额(
balanceOf)。 - 用 subgraph 查历史持仓(
Position实体)。 - 缓存结果,后续请求用缓存。
代码或图示
// multicall 查余额
const calls = tokens.map(token => ({
target: token.address,
callData: encodeBalanceOf(userAddress)
}));
const [, returnData( = await multicall.aggregate(calls);
const balances = returnData.map(parseBalance);
// subgraph 查历史持仓
const positions = await fetch('https://api.thegraph.com/subgraphs/name/...', {
method: 'POST',
body: JSON.stringify({
query: `{ positions(where: { user: "${userAddress}" }) { amount } }`
})
});
常见误区
- 误区:逐个查余额;正解:用 multicall 一次查完。
- 误区:每次刷新都查;正解:缓存结果。
- 误区:历史持仓用 eth_getLogs;正解:用 subgraph。
追问
- 为什么用 multicall?答:减少 RPC 次数。机制上 N 个代币余额用 multicall 一次查完,1 次 RPC。边界在于:multicall 内部执行 N 次调用,gas 消耗大。延伸:很多 DApp 用 multicall 查余额列表。
- 为什么用 subgraph?答:历史持仓查询复杂。机制上 subgraph 索引历史事件,DApp 用 GraphQL 查询。边界在于:subgraph 有索引延迟。延伸:很多 DApp 用 subgraph 查历史。
- 缓存怎么设计?答:短期缓存(如 30 秒)。机制上前端缓存余额,30 秒后刷新。边界在于:缓存太旧,用户看到过期数据。延伸:很多 DApp 显示"数据更新于 30 秒前"。
15.6.2-010 自建节点 vs 第三方 RPC(Infura/Alchemy)的取舍?
一句话结论
自建节点无限制、隐私好,但成本高、运维复杂;第三方 RPC 简单、成本低,但有配额、隐私差。
概念解释
- 自建节点:自己运行节点,无限制。
- 第三方 RPC:Infura/Alchemy,简单。
- 取舍:成本、运维、配额、隐私。
原理流程
- 早期项目用第三方 RPC(Infura/Alchemy)。
- 用户量大,配额不够,自建节点。
- 自建节点无限制,但需要运维。
代码或图示
自建 vs 第三方:
自建:无限制、隐私好,但成本高、运维复杂
第三方:简单、成本低,但有配额、隐私差
常见误区
- 误区:自建总是更好;正解:早期用第三方,后期自建。
- 误区:第三方 RPC 慢;正解:第三方节点性能好。
- 误区:自建节点简单;正解:运维复杂。
追问
- 什么时候自建节点?答:用户量大、配额不够。机制上第三方 RPC 配额不够,自建节点无限制。边界在于:自建成本高。延伸:很多项目在用户量大时自建。
- 自建节点怎么运维?答:监控、升级、备份。机制上节点需要持续运行,监控状态,升级版本。边界在于:运维复杂。延伸:很多项目用专业运维团队。
- 第三方 RPC 的隐私问题?答:第三方知道你的请求。机制上 Infura/Alchemy 知道你查什么、谁查的。边界在于:隐私敏感项目用自建。延伸:很多项目用第三方,接受隐私风险。
动手练习
练习 1:用 multicall 查多个代币余额
- 任务:写一个前端,用 multicall 一次查用户的 5 个代币余额。
- 验收标准:
- 用 multicall 一次查完,减少 RPC 次数。
- 显示余额列表。
- 处理失败(tryAggregate)。
练习 2:部署一个简单 subgraph
- 任务:部署一个 subgraph,索引 ERC-20 Transfer 事件,用 GraphQL 查询用户的转账记录。
- 验收标准:
- 写 schema 与映射。
- 部署到 The Graph。
- 用 GraphQL 查询用户转账记录。
自检清单
- [ ( 能否比较 eth_call 与 eth_getLogs?
- [ ( 能否解释 The Graph subgraph 的索引原理?
- [ ( 能否说出 RPC 限流的应对?
- [ ( 能否用 multicall 批量查询?
- [ ( 能否设计 subgraph schema?
- [ ( 能否选型 websocket vs 轮询?
- [ ( 能否处理区块重组?
- [ ( 能否解释 archive node 的使用场景?
延伸阅读
- The Graph 官方文档:
subgraph、schema、GraphQL。 - viem 官方文档:
publicClient、multicall。 - Foundry 官方文档:
fork testing、eth_call。 - Infura/Alchemy 官方文档:RPC 配额、限流。
- 最佳实践:缓存、multicall、subgraph。
待整理清单
- [ ( 补充自建节点的运维指南
- [ ( 补充 The Graph 托管服务 vs 自建 subgraph
- [ ( 补充 websocket 订阅的最佳实践