Queue huge multicall to avoid rate limit from rpcs

[oxSaturn]

I don't know if anyone ran into a similar issue before, but when you pass a huge array to contracts of multicall, you'll likely get rate limited by rpcs:

await publicClient.multicall({
  contracts: [
    // this is a huge array which might results in maybe hundreds of requests to rpc in a batch.
  ]
});

Due to the implementation of Promise.allSettled here https://github.com/wagmi-dev/viem/blob/47fcd4404153def3d5dc91086cac018e312ce8a4/src/actions/public/multicall.ts#L201-L212.

Thus I'm wondering if viem itself can have something built-in mechanism to split and queue that huge chunkedCalls, for instance, we can allow users to customize a multicall.handleChunkedCalls function and uses it when defined:

let aggregate3Results
if (handleChunkedCalls) {
    aggregate3Results = await handleChunkedCalls(
      chunkedCalls.map((calls) =>
      readContract(client, {
        abi: multicall3Abi,
        address: multicallAddress!,
        args: [calls],
        blockNumber,
        blockTag,
        functionName: 'aggregate3',
      }),
    )
  )
} else {
aggregate3Results = await Promise.allSettled(
    chunkedCalls.map((calls) =>
      readContract(client, {
        abi: multicall3Abi,
        address: multicallAddress!,
        args: [calls],
        blockNumber,
        blockTag,
        functionName: 'aggregate3',
      }),
    ),
  )
}

In handleChunkedCalls users will implement the queue system to split the huge chunkedCalls to avoid rate limit.

[immutablegoblin]

Also running into this issue currently, would be great to see this handled better.

Does anyone have any workarounds they are using for the time being?

[banky]

Not sure if OP has resolved this, but one approach might be to use Bluebird map (http://bluebirdjs.com/docs/getting-started.html) and cap the concurrency limit.