feat: handle unsupported chain id bff error + update supported chain list

libs/balances-and-allowances/src/constants/bff-balances-swr-config.ts

@@ -46,7 +46,12 @@ export const BFF_BALANCES_SWR_CONFIG: SWRConfiguration = {
     // Pause only if focus has been lost for more than ${FOCUS_HIDDEN_DELAY} seconds
     return Date.now() - focusLostTimestamp > FOCUS_HIDDEN_DELAY
   },
-  onErrorRetry: (_: unknown, __key, config, revalidate, { retryCount }) => {
+  onErrorRetry: (error: unknown, _key, config, revalidate, { retryCount }) => {
+    // Don't retry if error is "Unsupported chain"
+    if (error instanceof Error && error.message.toLowerCase().includes('unsupported chain')) {
+      return
+    }
+
     const timeout = config.errorRetryInterval * Math.pow(2, retryCount - 1)
 
     setTimeout(() => revalidate({ retryCount }), timeout)

libs/balances-and-allowances/src/hooks/usePersistBalancesFromBff.test.tsx

@@ -1,11 +1,11 @@
-import { Provider } from 'jotai'
+import { Provider, useAtomValue } from 'jotai'
 import { useHydrateAtoms } from 'jotai/utils'
 import React, { ReactNode } from 'react'
 
 import { mapSupportedNetworks, SupportedChainId } from '@cowprotocol/cow-sdk'
 import { PersistentStateByChain } from '@cowprotocol/types'
 
-import { renderHook } from '@testing-library/react'
+import { renderHook, waitFor } from '@testing-library/react'
 import fetchMock from 'jest-fetch-mock'
 import useSWR from 'swr'
 
@@ -14,16 +14,13 @@ import { PersistBalancesFromBffParams, usePersistBalancesFromBff } from './usePe
 
 import { BFF_BALANCES_SWR_CONFIG } from '../constants/bff-balances-swr-config'
 import { balancesAtom, BalancesState, balancesUpdateAtom } from '../state/balancesAtom'
-import * as isBffFailedAtom from '../state/isBffFailedAtom'
-import * as bffUtils from '../utils/isBffSupportedNetwork'
+import { bffUnsupportedChainsAtom } from '../state/isBffFailedAtom'
 
 // Enable fetch mocking
 fetchMock.enableMocks()
 
 // Mock modules
 jest.mock('swr')
-jest.mock('../utils/isBffSupportedNetwork')
-jest.mock('../state/isBffFailedAtom')
 
 // Create mock for useWalletInfo
 const mockUseWalletInfo = jest.fn()
@@ -34,7 +31,6 @@ jest.mock('@cowprotocol/wallet', () => ({
 }))
 
 describe('usePersistBalancesFromBff - invalidateCacheTrigger', () => {
-  const mockSetIsBffFailed = jest.fn()
   const mockWalletInfo = {
     chainId: SupportedChainId.MAINNET,
     account: '0x1234567890123456789012345678901234567890',
@@ -67,6 +63,7 @@ describe('usePersistBalancesFromBff - invalidateCacheTrigger', () => {
           } as BalancesState,
         ],
         [balancesUpdateAtom, mockBalancesUpdate],
+        [bffUnsupportedChainsAtom, new Set<SupportedChainId>()],
       ])
       return <>{children}</>
     }
@@ -82,8 +79,6 @@ describe('usePersistBalancesFromBff - invalidateCacheTrigger', () => {
     jest.clearAllMocks()
     fetchMock.resetMocks()
     mockUseWalletInfo.mockReturnValue(mockWalletInfo)
-    ;(isBffFailedAtom.useSetIsBffFailed as jest.Mock).mockReturnValue(mockSetIsBffFailed)
-    ;(bffUtils.isBffSupportedNetwork as jest.Mock).mockReturnValue(true)
   })
 
   describe('hardcoded SWR config', () => {
@@ -189,4 +184,104 @@ describe('usePersistBalancesFromBff - invalidateCacheTrigger', () => {
     })
   })
 
+  describe('unsupported chain handling', () => {
+    it('should not make requests for unsupported chains', () => {
+      const mockUseSWR = useSWR as jest.MockedFunction<typeof useSWR>
+      mockUseSWR.mockReturnValue({
+        data: undefined,
+        error: undefined,
+        isLoading: false,
+        isValidating: false,
+        mutate: jest.fn(),
+      } as ReturnType<typeof useSWR>)
+
+      const unsupportedChainParams: PersistBalancesFromBffParams = {
+        ...defaultParams,
+        chainId: SupportedChainId.SEPOLIA, // Unsupported network
+      }
+
+      renderHook(() => usePersistBalancesFromBff(unsupportedChainParams), { wrapper })
+
+      // Should not make SWR call for unsupported network
+      expect(mockUseSWR).toHaveBeenCalledWith(
+        null, // Key should be null for unsupported network
+        expect.any(Function),
+        BFF_BALANCES_SWR_CONFIG,
+      )
+    })
+
+    it('should add chain to unsupported list when "Unsupported chain" error occurs', async () => {
+      const mockUseSWR = useSWR as jest.MockedFunction<typeof useSWR>
+      const unsupportedChainError = new Error('Unsupported chain')
+
+      mockUseSWR.mockReturnValue({
+        data: undefined,
+        error: unsupportedChainError,
+        isLoading: false,
+        isValidating: false,
+        mutate: jest.fn(),
+      } as ReturnType<typeof useSWR>)
+
+      const useUnsupportedChains = (): Set<SupportedChainId> => {
+        usePersistBalancesFromBff(defaultParams)
+        return useAtomValue(bffUnsupportedChainsAtom)
+      }
+
+      const { result } = renderHook(() => useUnsupportedChains(), { wrapper })
+
+      // Wait for effect to run and add chain to unsupported list
+      await waitFor(
+        () => {
+          expect(result.current.has(defaultParams.chainId)).toBe(true)
+        },
+        { timeout: 3000 },
+      )
+    })
+
+    it('should stop making requests after chain is added to unsupported list', () => {
+      const mockUseSWR = useSWR as jest.MockedFunction<typeof useSWR>
+
+      const wrapperWithUnsupportedChain = ({ children }: { children: ReactNode }): ReactNode => {
+        const HydrateAtoms = ({ children }: { children: ReactNode }): ReactNode => {
+          useHydrateAtoms([
+            [
+              balancesAtom,
+              {
+                isLoading: false,
+                chainId: SupportedChainId.MAINNET,
+                values: {},
+                fromCache: false,
+              } as BalancesState,
+            ],
+            [balancesUpdateAtom, mockBalancesUpdate],
+            [bffUnsupportedChainsAtom, new Set([SupportedChainId.MAINNET])], // Chain is in unsupported list
+          ])
+          return <>{children}</>
+        }
+
+        return (
+          <Provider>
+            <HydrateAtoms>{children}</HydrateAtoms>
+          </Provider>
+        )
+      }
+
+      mockUseSWR.mockReturnValue({
+        data: undefined,
+        error: undefined,
+        isLoading: false,
+        isValidating: false,
+        mutate: jest.fn(),
+      } as ReturnType<typeof useSWR>)
+
+      renderHook(() => usePersistBalancesFromBff(defaultParams), { wrapper: wrapperWithUnsupportedChain })
+
+      // Should not make SWR call because chain is in unsupported list
+      expect(mockUseSWR).toHaveBeenCalledWith(
+        null, // Key should be null
+        expect.any(Function),
+        BFF_BALANCES_SWR_CONFIG,
+      )
+    })
+  })
 })

libs/balances-and-allowances/src/hooks/usePersistBalancesFromBff.ts

@@ -10,11 +10,12 @@ import useSWR, { SWRConfiguration } from 'swr'
 
 import { BFF_BALANCES_SWR_CONFIG } from '../constants/bff-balances-swr-config'
 import { balancesAtom, BalancesState, balancesUpdateAtom } from '../state/balancesAtom'
-import { useSetIsBffFailed } from '../state/isBffFailedAtom'
-import { isBffSupportedNetwork } from '../utils/isBffSupportedNetwork'
+import { useSetIsBffFailed, useAddUnsupportedChainId } from '../state/isBffFailedAtom'
+import { useIsBffSupportedNetwork } from '../utils/isBffSupportedNetwork'
 
 type BalanceResponse = {
   balances: Record<string, string> | null
+  message?: string
 }
 
 export interface PersistBalancesFromBffParams {
@@ -25,15 +26,45 @@ export interface PersistBalancesFromBffParams {
   tokenAddresses: string[]
 }
 
+function isUnsupportedChainError(errorMessage: string): boolean {
+  return errorMessage.toLowerCase().includes('unsupported chain')
+}
+
+function parseErrorResponse(data: unknown, statusText: string): string {
+  if (typeof data === 'object' && data !== null && 'message' in data) {
+    return String(data.message)
+  }
+  return statusText
+}
+
+async function parseBffResponse(res: Response): Promise<BalanceResponse | { message?: string }> {
+  try {
+    return await res.json()
+  } catch {
+    return { message: res.statusText }
+  }
+}
+
+function handleBffError(res: Response, data: BalanceResponse | { message?: string }): never {
+  const errorMessage = parseErrorResponse(data, res.statusText)
+
+  if (isUnsupportedChainError(errorMessage)) {
+    throw new Error('Unsupported chain')
+  }
+
+  throw new Error(`BFF error: ${res.status} ${res.statusText}`)
+}
+
 export function usePersistBalancesFromBff(params: PersistBalancesFromBffParams): void {
   const { account, chainId, invalidateCacheTrigger, tokenAddresses } = params
 
   const { chainId: activeChainId, account: connectedAccount } = useWalletInfo()
   const targetAccount = account ?? connectedAccount
   const targetChainId = chainId ?? activeChainId
-  const isSupportedNetwork = isBffSupportedNetwork(targetChainId)
+  const isSupportedNetwork = useIsBffSupportedNetwork(targetChainId)
 
   const setIsBffFailed = useSetIsBffFailed()
+  const addUnsupportedChainId = useAddUnsupportedChainId()
 
   const lastTriggerRef = useRef(invalidateCacheTrigger)
 
@@ -59,8 +90,15 @@ export function usePersistBalancesFromBff(params: PersistBalancesFromBffParams):
   }, [setBalances, isBalancesLoading, targetChainId, targetAccount])
 
   useEffect(() => {
+    const hasUnsupportedChainError = error instanceof Error && 
+      isUnsupportedChainError(error.message)
+
+    if (hasUnsupportedChainError) {
+      addUnsupportedChainId(targetChainId)
+    }
+
     setIsBffFailed(!!error)
-  }, [error, setIsBffFailed])
+  }, [error, setIsBffFailed, addUnsupportedChainId, targetChainId])
 
   useEffect(() => {
     if (!targetAccount || !data || error) return
@@ -114,18 +152,21 @@ export async function getBffBalances(
 
   try {
     const res = await fetch(fullUrl)
-    const data: BalanceResponse = await res.json()
+    const data = await parseBffResponse(res)
 
     if (!res.ok) {
-      return Promise.reject(new Error(`BFF error: ${res.status} ${res.statusText}`))
+      handleBffError(res, data)
     }
 
-    if (!data.balances) {
+    if (!('balances' in data) || !data.balances) {
       return null
     }
 
     return data.balances
   } catch (error) {
-    return Promise.reject(error)
+    if (error instanceof Error && isUnsupportedChainError(error.message)) {
+      throw new Error('Unsupported chain')
+    }
+    throw error
   }
 }

libs/balances-and-allowances/src/state/isBffFailedAtom.ts

@@ -1,6 +1,8 @@
 import { useSetAtom } from 'jotai'
 import { atom, useAtomValue } from 'jotai/index'
 
+import { SupportedChainId } from '@cowprotocol/cow-sdk'
+
 export const isBffFailedAtom = atom(false)
 
 export function useIsBffFailed(): boolean {
@@ -10,3 +12,17 @@ export function useIsBffFailed(): boolean {
 export function useSetIsBffFailed(): (value: boolean) => void {
   return useSetAtom(isBffFailedAtom)
 }
+
+export const bffUnsupportedChainsAtom = atom(new Set<SupportedChainId>())
+
+export function useAddUnsupportedChainId(): (chainId: SupportedChainId) => void {
+  const setAtom = useSetAtom(bffUnsupportedChainsAtom)
+  return (chainId) => {
+    setAtom((prev) => {
+      if (prev.has(chainId)) {
+        return prev
+      }
+      return new Set([...prev, chainId])
+    })
+  }
+}

libs/balances-and-allowances/src/updaters/BalancesAndAllowancesUpdater.tsx

@@ -16,6 +16,7 @@ import { BASIC_MULTICALL_SWR_CONFIG } from '../consts'
 import { useNativeTokenBalance } from '../hooks/useNativeTokenBalance'
 import { useSwrConfigWithPauseForNetwork } from '../hooks/useSwrConfigWithPauseForNetwork'
 import { useUpdateTokenBalance } from '../hooks/useUpdateTokenBalance'
+import { useIsBffSupportedNetwork } from '../utils/isBffSupportedNetwork'
 
 // A small gap between balances and allowances refresh intervals is needed to avoid high load to the node at the same time
 const RPC_BALANCES_SWR_CONFIG: SWRConfiguration = { ...BASIC_MULTICALL_SWR_CONFIG, refreshInterval: ms`31s` }
@@ -40,6 +41,7 @@ export function BalancesAndAllowancesUpdater({
   isBffEnabled,
 }: BalancesAndAllowancesUpdaterProps): ReactNode {
   const updateTokenBalance = useUpdateTokenBalance()
+  const isBffSupported = useIsBffSupportedNetwork(chainId)
 
   const allTokens = useAllActiveTokens()
   const { data: nativeTokenBalance } = useNativeTokenBalance(account, chainId)
@@ -71,7 +73,7 @@ export function BalancesAndAllowancesUpdater({
 
   return (
     <>
-      {isBffEnabled && (
+      {isBffEnabled && isBffSupported && (
         <BalancesBffUpdater
           account={account}
           chainId={chainId}

libs/balances-and-allowances/src/utils/isBffSupportedNetwork.ts

@@ -1,8 +1,17 @@
+import { useAtomValue } from 'jotai'
+
 import { SupportedChainId } from '@cowprotocol/cow-sdk'
 
+import { bffUnsupportedChainsAtom } from '../state/isBffFailedAtom'
+
 // TODO: check before Plasma launch. Currently unsupported on 2025/10/20
-const UNSUPPORTED_BFF_NETWORKS = [SupportedChainId.LENS, SupportedChainId.SEPOLIA, SupportedChainId.PLASMA]
+const UNSUPPORTED_BFF_NETWORKS = [SupportedChainId.PLASMA, SupportedChainId.SEPOLIA]
 
 export function isBffSupportedNetwork(chainId: SupportedChainId): boolean {
   return !UNSUPPORTED_BFF_NETWORKS.includes(chainId)
 }
+
+export function useIsBffSupportedNetwork(chainId: SupportedChainId): boolean {
+  const unsupportedChains = useAtomValue(bffUnsupportedChainsAtom)
+  return isBffSupportedNetwork(chainId) && !unsupportedChains.has(chainId)
+}