批量调用合约ownerOf时MetaMask报Failed to fetch错误如何修复

该错误本质是短时间内向RPC节点发起的请求总量/请求密度超过节点限流阈值，被节点主动拦截断开连接导致。
你当前代码循环串行发起ownerOf合约调用，MetaMask默认对接的是公开公共RPC节点，这类节点对单用户的单位时间请求数有严格限制：调用200次时未触达限流阈值可以正常返回，累计2500次调用的总请求量、请求密度超过节点限制后，就会直接抛出MetaMask - RPC Error: Failed to fetch错误。

可根据自身场景选择以下任意一种方案解决：

• 方案1：增加请求限流控制+失败重试逻辑
  不要无间隔持续向节点发请求，控制请求并发数、增加请求间隔，遇到限流报错时自动等待后重试，参考实现代码：

// 并发控制工具
async function asyncPool<T, R>(concurrency: number, items: T[], fn: (item: T) => Promise<R>): Promise<R[]> {
  const result: Promise<R>[] = [];
  const executing: Promise<void>[] = [];
  for (const item of items) {
    const task = Promise.resolve().then(() => fn(item));
    result.push(task);
    const done: any = task.then(() => executing.splice(executing.indexOf(done), 1));
    executing.push(done);
    if (executing.length >= concurrency) {
      await Promise.race(executing);
    }
  }
  return Promise.all(result);
}

export async function list() {
  const MAX_TOKEN_ID = 2500;
  const web3 = new Web3(Web3.givenProvider ||'http://localhost:8080');
  const contract = new web3.eth.Contract(ERC721ABI as AbiItem[], CONTRACT);
  const ownerSet = new Set<string>();
  const tokenIds = Array.from({ length: MAX_TOKEN_ID }, (_, i) => i + 1);

  // 控制同时发起的请求数为3，避免请求密度过高
  await asyncPool(3, tokenIds, async (tokenId) => {
    try {
      const address = await contract.methods.ownerOf(tokenId).call();
      ownerSet.add(address);
      // 单次请求后加50ms间隔，进一步降低请求频率
      await new Promise(resolve => setTimeout(resolve, 50));
    } catch (err) {
      // 触发限流时等待1秒后重试
      if ((err as Error).message?.includes('Failed to fetch')) {
        await new Promise(resolve => setTimeout(resolve, 1000));
        const retryAddress = await contract.methods.ownerOf(tokenId).call();
        ownerSet.add(retryAddress);
      } else {
        throw err;
      }
    }
  });

  return Array.from(ownerSet).map(address => ({ address }));
}

• 方案2：替换为专属RPC节点
  公共RPC节点限流阈值极低，可从第三方节点服务商处申请专属RPC接口，替换Web3初始化时使用的provider地址。专属节点的限流阈值远高于公共节点，2500次查询请求基本不会触发限流。
• 方案3：使用RPC批量请求能力，降低总请求数
  大部分EVM节点支持JSON-RPC批量请求，可以把数十个ownerOf调用打包成一次RPC请求发送，总请求量可以降低到原来的1/50甚至更低，从根源上避免触发限流，参考实现代码：

export async function list() {
  const MAX_TOKEN_ID = 2500;
  const web3 = new Web3(Web3.givenProvider ||'http://localhost:8080');
  const contract = new web3.eth.Contract(ERC721ABI as AbiItem[], CONTRACT);
  const ownerSet = new Set<string>();
  const BATCH_SIZE = 50; // 单批打包50个请求，避免单包过大被节点拒绝

  for (let i = 1; i <= MAX_TOKEN_ID; i += BATCH_SIZE) {
    const batch = new web3.BatchRequest();
    const batchEnd = Math.min(i + BATCH_SIZE - 1, MAX_TOKEN_ID);
    const taskList = [];
    for (let tokenId = i; tokenId <= batchEnd; tokenId++) {
      taskList.push(new Promise((resolve, reject) => {
        batch.add(
          contract.methods.ownerOf(tokenId).call.request({}, (err, res) => {
            if (err) return reject(err);
            resolve(res);
          })
        );
      }));
    }
    await batch.execute();
    const batchResult = await Promise.all(taskList);
    batchResult.forEach(addr => ownerSet.add(addr as string));
    // 每批请求完成后等待200ms再发下一批
    await new Promise(resolve => setTimeout(resolve, 200));
  }

  return Array.from(ownerSet).map(address => ({ address }));
}

额外提示：如果目标ERC721合约本身自带批量查询持有者的扩展方法，优先使用合约原生批量查询接口，查询效率会比手动打包RPC请求更高。

内容的提问来源于stack exchange，提问作者judy