fix(recent-block-cache): Reduce fetch fan out and preserve negative cache entries.

[metalurgical]

Description

Reduce fetch fan out and preserve negative cache entries.

Changes

• Fetch cache miss chunks through fetch_values(keys, block) directly instead of expanding them into individual key requests
• Preserve negative cache entries instead of removing empty entries
• Add test for negative cache entries

How to test

cargo nextest run

[claude]

Claude Code Review

This pull request is from a fork — automated review is disabled. A repository maintainer can comment @claude review to run a one-time review.

[gemini-code-assist]

Code Review

This pull request refactors the RecentBlockCache by removing the request_sharing dependency and simplifying the fetching logic into a single retry loop within fetch_inner_many. It also corrects a bug in the garbage collection process where negative cache entries (empty results) were being prematurely evicted, and adds a regression test to verify their persistence. Review feedback identified that the new retry implementation introduces unnecessary latency on the final failure, loses original error context by using anyhow::bail!, and violates repository guidelines regarding detailed error reporting for batch fetches.

[gemini-code-assist]

The current retry logic in fetch_inner_many has several issues:

1. Unnecessary Latency: It performs a tokio::time::sleep even after the final retry attempt fails, adding redundant delay to the overall request time.
2. Error Context Loss: By using anyhow::bail!, the original RPC error (e.g., timeout, node error) is discarded. Using .context() preserves the root cause for better troubleshooting.
3. Batch Error Detail: According to repository guidelines for batch fetches, the implementation should explicitly indicate which items failed and provide error details for each, rather than returning a single error for the entire batch. Please ensure the response structure reflects individual item statuses.

        let mut keys = keys;
        for i in 0..=self.maximum_retries {
            let current_keys = if i == self.maximum_retries {
                keys
            } else {
                keys.clone()
            };
            match self.fetcher.fetch_values(current_keys, block).await {
                Ok(values) => return Ok(values),
                Err(err) => {
                    if i == self.maximum_retries {
                        return Err(anyhow::Error::from(err).context("could not fetch liquidity"));
                    }
                    tracing::warn!(?err, "retrying fetch");
                    tokio::time::sleep(self.delay_between_retries).await;
                }
            }
        }
        unreachable!()

References

1. When fetching a batch of items where individual fetches can fail, do not silently ignore errors. The API response should explicitly indicate which items failed and provide error details for each failure.

[metalurgical]

Point 1 and 2 have been corrected.

Point 3 is a trait redesign, Result<Vec<V>> will need to become HashMap<K, Result<Vec<V>> in multiple places for this.

[gemini-code-assist]

Code Review

This pull request refactors the RecentBlockCache to implement batch fetching and simplified retry logic, removing the dependency on individual request sharing. It also fixes a bug in the cache's garbage collection logic that caused negative cache entries to be prematurely evicted and adds a regression test. A high-severity recommendation was made to include an early return for empty key sets in fetch_inner_many to avoid unnecessary RPC calls.