Stop caching each chain's own asset twice

The pair cache matched entries with a linear scan comparing tokenId with
===. Pairs written without a tokenId key read back as undefined, and
undefined === null is false, so every refresh appended a second pair for
each chain's own asset. A real cache had 202 pairs where only 137 were
distinct, inflating each rate query and pushing it over the 100-pair chunk
size into an extra request.

Build the pair lists from keyed maps instead, using the same key
loadExchangeRateCache de-duplicates with, so a missing tokenId and an
explicit null collapse to one pair. Existing duplicates are merged away on
the next refresh.

Author: peachbits

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 - added: Verbose logging for exchange rate queries: the request body, resolved/rate-less counts, and errors are captured when the Verbose Logging setting is enabled.
 - added: Exchange-rate cache snapshot in the support log output, plus a `rates-cache-replay` script that re-runs those queries against the rates server and reports the result for each pair.
+- fixed: Exchange rate queries no longer request each chain's own asset twice, which had been inflating every rate query with duplicate pairs.
 
 ## 4.50.0 (2026-07-21)
 

src/__tests__/actions/ExchangeRateActions.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from '@jest/globals'
+
+import {
+  type ExchangeRateCache,
+  mergePairCache
+} from '../../actions/ExchangeRateActions'
+
+type PairCache = ReturnType<typeof mergePairCache>
+
+const PAIR_EXPIRATION = 5000
+const rateEntry = {
+  current: 1,
+  yesterday: 1,
+  yesterdayTimestamp: 0,
+  expiration: 0
+}
+
+const noRates: ExchangeRateCache = { crypto: {}, fiat: {} }
+const emptyCache: PairCache = { cryptoPairs: [], fiatPairs: [] }
+
+describe('mergePairCache', () => {
+  it('collapses a pair stored without a tokenId and one stored with null', () => {
+    // Older cache entries were written without a `tokenId` key at all, so they
+    // read back as undefined, while newer ones carry an explicit null. Both
+    // mean "the chain's own asset".
+    const previous: PairCache = {
+      cryptoPairs: [
+        {
+          asset: { pluginId: 'bitcoin', tokenId: undefined },
+          targetFiat: 'iso:USD',
+          isoDate: undefined,
+          expiration: 1
+        },
+        {
+          asset: { pluginId: 'bitcoin', tokenId: null },
+          targetFiat: 'iso:USD',
+          isoDate: undefined,
+          expiration: 1
+        }
+      ],
+      fiatPairs: []
+    }
+
+    const out = mergePairCache(noRates, previous, PAIR_EXPIRATION)
+
+    expect(out.cryptoPairs).toHaveLength(1)
+  })
+
+  it('does not append a duplicate for a chain asset already cached', () => {
+    const previous: PairCache = {
+      cryptoPairs: [
+        // Written with no tokenId key, so it reads back off disk as undefined:
+        {
+          asset: { pluginId: 'bitcoin', tokenId: undefined },
+          targetFiat: 'iso:USD',
+          isoDate: undefined,
+          expiration: 1
+        }
+      ],
+      fiatPairs: []
+    }
+    const rates: ExchangeRateCache = {
+      crypto: { bitcoin: { '': { 'iso:USD': rateEntry } } },
+      fiat: {}
+    }
+
+    const out = mergePairCache(rates, previous, PAIR_EXPIRATION)
+
+    expect(out.cryptoPairs).toHaveLength(1)
+    expect(out.cryptoPairs[0].asset.tokenId).toBeNull()
+    expect(out.cryptoPairs[0].expiration).toBe(PAIR_EXPIRATION)
+  })
+
+  it('stays stable across repeated merges', () => {
+    const rates: ExchangeRateCache = {
+      crypto: { bitcoin: { '': { 'iso:USD': rateEntry } } },
+      fiat: { 'iso:EUR': { 'iso:USD': rateEntry } }
+    }
+
+    let cache = emptyCache
+    for (let i = 0; i < 5; i++) {
+      cache = mergePairCache(rates, cache, PAIR_EXPIRATION)
+    }
+
+    expect(cache.cryptoPairs).toHaveLength(1)
+    expect(cache.fiatPairs).toHaveLength(1)
+  })
+
+  it('keeps tokens separate from their chain asset', () => {
+    const rates: ExchangeRateCache = {
+      crypto: {
+        ethereum: {
+          '': { 'iso:USD': rateEntry },
+          a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48: { 'iso:USD': rateEntry }
+        }
+      },
+      fiat: {}
+    }
+
+    const out = mergePairCache(rates, emptyCache, PAIR_EXPIRATION)
+
+    const tokenIds = out.cryptoPairs.map(pair => pair.asset.tokenId)
+    expect(tokenIds).toHaveLength(2)
+    expect(tokenIds).toContain(null)
+    expect(tokenIds).toContain('a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
+  })
+
+  it('keeps the same asset against different target fiats separate', () => {
+    const rates: ExchangeRateCache = {
+      crypto: {
+        bitcoin: { '': { 'iso:USD': rateEntry, 'iso:EUR': rateEntry } }
+      },
+      fiat: {}
+    }
+
+    const out = mergePairCache(rates, emptyCache, PAIR_EXPIRATION)
+
+    expect(out.cryptoPairs).toHaveLength(2)
+  })
+})

src/actions/ExchangeRateActions.ts

@@ -478,58 +478,16 @@ async function fetchExchangeRates(
   await Promise.allSettled(promises)
 
   // Merge successful rate responses into the pair cache
-  const cryptoPairCache = [...(exchangeRateCache?.cryptoPairs ?? [])]
-  const fiatPairCache = [...(exchangeRateCache?.fiatPairs ?? [])]
-  for (const [pluginId, tokenObj] of Object.entries(rates.crypto)) {
-    for (const [tokenId, rateObj] of Object.entries(tokenObj)) {
-      for (const targetFiat of Object.keys(rateObj)) {
-        const edgeTokenId = tokenId === '' ? null : tokenId
-        const cryptoPairIndex = cryptoPairCache.findIndex(
-          pair =>
-            pair.asset.pluginId === pluginId &&
-            pair.asset.tokenId === edgeTokenId &&
-            pair.targetFiat === targetFiat
-        )
-        if (cryptoPairIndex === -1) {
-          cryptoPairCache.push({
-            asset: { pluginId, tokenId: edgeTokenId },
-            targetFiat,
-            isoDate: undefined,
-            expiration: pairExpiration
-          })
-        } else {
-          cryptoPairCache[cryptoPairIndex] = {
-            asset: { pluginId, tokenId: edgeTokenId },
-            targetFiat,
-            isoDate: undefined,
-            expiration: pairExpiration
-          }
-        }
-      }
-    }
-  }
-  for (const [fiatCode, fiatObj] of Object.entries(rates.fiat)) {
-    for (const targetFiat of Object.keys(fiatObj)) {
-      const fiatPairIndex = fiatPairCache.findIndex(
-        pair => pair.fiatCode === fiatCode && pair.targetFiat === targetFiat
-      )
-      if (fiatPairIndex === -1) {
-        fiatPairCache.push({
-          fiatCode,
-          targetFiat,
-          isoDate: undefined,
-          expiration: pairExpiration
-        })
-      } else {
-        fiatPairCache[fiatPairIndex] = {
-          fiatCode,
-          targetFiat,
-          isoDate: undefined,
-          expiration: pairExpiration
-        }
-      }
-    }
-  }
+  const { cryptoPairs: cryptoPairCache, fiatPairs: fiatPairCache } =
+    mergePairCache(
+      rates,
+      {
+        cryptoPairs: exchangeRateCache?.cryptoPairs ?? [],
+        fiatPairs: exchangeRateCache?.fiatPairs ?? []
+      },
+      pairExpiration
+    )
+
   // Update the in-memory cache:
   exchangeRateCache = {
     rates,
@@ -545,6 +503,80 @@ async function fetchExchangeRates(
     })
 }
 
+/**
+ * Key for a crypto pair. A missing `tokenId` and an explicit `null` both mean
+ * "the chain's own asset", so they must produce the same key — this matches
+ * how `loadExchangeRateCache` de-duplicates the pairs it reads from disk.
+ */
+const cryptoPairKey = (
+  pluginId: string,
+  tokenId: string | null | undefined,
+  targetFiat: string
+): string => `${pluginId}${tokenId != null ? `_${tokenId}` : ''}_${targetFiat}`
+
+const fiatPairKey = (fiatCode: string, targetFiat: string): string =>
+  `${fiatCode}_${targetFiat}`
+
+/**
+ * Merges the assets we just fetched rates for into the subscribed pair lists.
+ *
+ * Pairs are keyed rather than matched by a linear scan, so an entry stored
+ * without a `tokenId` key and one stored with an explicit `null` collapse into
+ * a single pair. Comparing the two with `===` treated them as different
+ * assets, which appended a duplicate for every chain's own asset on each
+ * refresh and inflated later rate queries.
+ *
+ * Exported for unit tests.
+ */
+export function mergePairCache(
+  rates: ExchangeRateCache,
+  previous: { cryptoPairs: CryptoFiatPair[]; fiatPairs: FiatFiatPair[] },
+  pairExpiration: number
+): { cryptoPairs: CryptoFiatPair[]; fiatPairs: FiatFiatPair[] } {
+  const cryptoPairs = new Map<string, CryptoFiatPair>()
+  for (const pair of previous.cryptoPairs) {
+    const key = cryptoPairKey(
+      pair.asset.pluginId,
+      pair.asset.tokenId,
+      pair.targetFiat
+    )
+    cryptoPairs.set(key, pair)
+  }
+  for (const [pluginId, tokenObj] of Object.entries(rates.crypto)) {
+    for (const [tokenId, rateObj] of Object.entries(tokenObj)) {
+      for (const targetFiat of Object.keys(rateObj)) {
+        const edgeTokenId = tokenId === '' ? null : tokenId
+        cryptoPairs.set(cryptoPairKey(pluginId, edgeTokenId, targetFiat), {
+          asset: { pluginId, tokenId: edgeTokenId },
+          targetFiat,
+          isoDate: undefined,
+          expiration: pairExpiration
+        })
+      }
+    }
+  }
+
+  const fiatPairs = new Map<string, FiatFiatPair>()
+  for (const pair of previous.fiatPairs) {
+    fiatPairs.set(fiatPairKey(pair.fiatCode, pair.targetFiat), pair)
+  }
+  for (const [fiatCode, fiatObj] of Object.entries(rates.fiat)) {
+    for (const targetFiat of Object.keys(fiatObj)) {
+      fiatPairs.set(fiatPairKey(fiatCode, targetFiat), {
+        fiatCode,
+        targetFiat,
+        isoDate: undefined,
+        expiration: pairExpiration
+      })
+    }
+  }
+
+  return {
+    cryptoPairs: Array.from(cryptoPairs.values()),
+    fiatPairs: Array.from(fiatPairs.values())
+  }
+}
+
 const getYesterdayDateRoundDownHour = (now?: Date | number): Date => {
   const yesterday = now == null ? new Date() : new Date(now)
   yesterday.setMinutes(0)