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.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]
 
 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)
+}