refactor: improve votes caching behavoir

[rickstaa]

@ECWireless, this is just a quick pull request to showcase what I mean. Please feel free to use whatever caching behavior you think makes the most sense. It could be even better to upgrade Apollo and make use of persistent cache for proposals that are already finished. Maybe create a follow up issue for this.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated (UTC)
explorer-arbitrum-one	Ready	Preview, Comment	Feb 3, 2026 9:28pm

[Copilot]

Pull request overview

This PR refactors the votes caching behavior in the Treasury Vote Table component to improve performance by avoiding redundant ENS lookups. The changes introduce a module-level cache for ENS names and modify Apollo's fetch policy to better balance cache usage with data freshness.

Changes:

• Added module-level ensCache to persist ENS name lookups across component renders and navigations
• Changed Apollo query fetch policies from default to "cache-and-network" for both votes and vote events queries
• Updated ENS lookup logic to check and populate the module-level cache

Comments suppressed due to low confidence (2)

components/Treasury/TreasuryVoteTable/index.tsx:86

• Inconsistent cache behavior when ENS lookup fails. If getEnsForVotes throws an exception (caught at line 83), the address is never added to ensCache. This means failed lookups will be retried on every render, potentially causing repeated failed network requests for addresses that consistently fail to resolve.

Consider caching the formatted address even when the lookup fails, to prevent repeated attempts for the same failing address.

          } catch (e) {
            console.warn(`Failed to fetch ENS for ${address}`, e);
          }
        })

components/Treasury/TreasuryVoteTable/index.tsx:108

• Logic error: the condition at lines 51-56 clears votes when data is missing, but doesn't prevent decorateVotes from executing afterwards. This means decorateVotes() at line 108 will still run with undefined data, causing uniqueVoters to be an empty array and votes to be set to an empty array anyway. The early setVotes([]) at line 55 is redundant and the condition should use an early return to prevent unnecessary processing.

    if (
      !treasuryVotesData?.treasuryVotes ||
      !treasuryVoteEventsData?.treasuryVoteEvents
    ) {
      setVotes([]);
    }
    const decorateVotes = async () => {
      setVotesLoading(true);
      const uniqueVoters = Array.from(
        new Set(treasuryVotesData?.treasuryVotes?.map((v) => v.voter.id) ?? [])
      );
      const localEnsCache: { [address: string]: string } = {};

      await Promise.all(
        uniqueVoters.map(async (address) => {
          try {
            if (localEnsCache[address]) {
              return;
            }
            if (ensCache[address]) {
              localEnsCache[address] = ensCache[address];
              return;
            }

            const ensAddress = await getEnsForVotes(address);

            if (ensAddress && ensAddress.name) {
              localEnsCache[address] = ensAddress.name;
            } else {
              localEnsCache[address] = formatAddress(address);
            }
            ensCache[address] = localEnsCache[address];
          } catch (e) {
            console.warn(`Failed to fetch ENS for ${address}`, e);
          }
        })
      );
      const votes =
        treasuryVotesData?.treasuryVotes?.map((vote) => {
          const events = (treasuryVoteEventsData?.treasuryVoteEvents ?? [])
            .filter((event) => event.voter.id === vote.voter.id)
            .sort((a, b) => b.timestamp - a.timestamp);

          const latestEvent = events[0];
          const ensName = localEnsCache[vote.voter.id] ?? "";

          return {
            ...vote,
            reason: latestEvent?.reason || vote.reason || "",
            ensName,
            transactionHash: latestEvent?.transaction.id ?? "",
            timestamp: latestEvent?.timestamp,
          };
        }) ?? [];
      setVotes(votes as Vote[]);
      setVotesLoading(false);
    };
    decorateVotes();

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Race condition vulnerability in concurrent ENS lookups. When multiple parallel lookups occur for the same address (via Promise.all), they all check ensCache at the same time (line 70), all miss, and then all make the same getEnsForVotes call (line 75). Each then updates ensCache (line 82), causing redundant network requests. This defeats the purpose of the cache.

Consider tracking in-flight requests to prevent duplicate lookups. A common pattern is to store the Promise itself in the cache while the request is pending, so subsequent checks can await the same Promise rather than initiating new requests.

[Copilot]

Potential memory leak: the module-level ensCache grows indefinitely without any expiration or size limit. Over time, as users navigate through multiple proposals with different voters, this cache will accumulate entries for all voters ever seen, consuming increasing amounts of memory for the lifetime of the browser session.

Consider implementing a cache size limit (e.g., LRU eviction) or time-based expiration for ENS entries. Alternatively, since ENS names rarely change, document this as an intentional design decision if unbounded growth is acceptable for this use case.

Suggested change

	const ensCache: Record<string, string> = {};
	// Bounded to avoid unbounded memory growth over long-lived sessions.
	const ENS_CACHE_MAX_ENTRIES = 500;
	const ensCache: Record<string, string> = new Proxy<Record<string, string>>(
	{} as Record<string, string>,
	{
	set(target, prop: string | symbol, value: string): boolean {
	// Only enforce limits for string keys; symbols are passed through.
	if (typeof prop === "string") {
	if (!Object.prototype.hasOwnProperty.call(target, prop)) {
	const keys = Object.keys(target);
	if (keys.length >= ENS_CACHE_MAX_ENTRIES) {
	// Simple FIFO eviction: remove the oldest inserted key.
	delete target[keys[0]];
	}
	}
	}
	// Perform the actual write.
	// Type assertion because Proxy handler uses loose typing on 'prop'.
	(target as any)[prop] = value;
	return true;
	},
	}
	);

[ECWireless]

Forwarding the comment at #457 (comment) to potentially move this to a global hook