@berachain/berajs 0.2.13 → 0.3.1

package/src/hooks/enso/useZapStakeBera.ts

@@ -8,6 +8,7 @@ import { useBeraWallet } from "@berachain/wagmi/hooks";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
 import { ensoErc4626 } from "../../actions/dex/aggregators/enso/ensoErc4626";
+import { useBeraFlag } from "../../contexts/BeraFlags/BeraFlags";
 import { POLLING } from "../../enum/polling";
 import type { MinimalERC20 } from "../../types/dex";
 import type { DefaultHookOptions } from "../../types/global";
@@ -37,6 +38,9 @@ export function useZapStakeBera(
   options?: DefaultHookOptions,
 ) {
   const { address: account } = useBeraWallet();
+  const proxyAggregatorsThroughVercel = useBeraFlag(
+    "proxyAggregatorsThroughVercel",
+  );
   // enso route simulation needs a real EOA-like address; zeroAddress can fail simulation.
   // use the connected wallet when available, otherwise fallback to our configured aggregator executor.
   const quoteAccount =
@@ -59,6 +63,7 @@ export function useZapStakeBera(
         slippage,
         underlyingToken,
         tokenOut,
+        proxyAggregatorsThroughVercel ?? false,
       ] as const)
     : null;
 
@@ -72,6 +77,7 @@ export function useZapStakeBera(
       slippage,
       underlyingToken,
       tokenOut,
+      proxyAggregatorsThroughVercel,
     ]) => {
       const rawAmount = parseUnits(amount, inputToken.decimals).toString();
 
@@ -82,6 +88,7 @@ export function useZapStakeBera(
         underlyingToken: underlyingToken,
         tokenOut: tokenOut,
         slippage,
+        proxyAggregatorsThroughVercel,
       });
     },
     {
@@ -104,7 +111,7 @@ export function useZapStakeBera(
     data: {
       ...swrResponse.data,
       priceImpactPercentage,
-      isCrossChain: inputToken && tokenOut.chainId !== inputToken?.chainId,
+      isCrossChain: swrResponse.data?.isCrossChain,
     },
   };
 }

package/src/hooks/enso/useZapStakeBera.unit.test.ts

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { MinimalERC20 } from "../../types/dex";
+import { useZapStakeBera } from "./useZapStakeBera";
+
+type CapturedFetcher = (key: readonly unknown[]) => Promise<unknown>;
+
+const { captured, getQuote } = vi.hoisted(() => ({
+  captured: {
+    key: null as readonly unknown[] | null,
+    fetcher: null as CapturedFetcher | null,
+  },
+  getQuote: vi.fn(),
+}));
+
+vi.mock("@berachain/wagmi/hooks", () => ({
+  useBeraWallet: () => ({
+    address: "0x1111111111111111111111111111111111111111",
+  }),
+}));
+
+vi.mock("@berachain/utils/pkg/swr", () => ({
+  useSWR: vi.fn(
+    (key: readonly unknown[] | null, fetcher: CapturedFetcher | null) => {
+      captured.key = key;
+      captured.fetcher = fetcher;
+      return { data: undefined, refresh: vi.fn() };
+    },
+  ),
+}));
+
+vi.mock("../../contexts/BeraFlags/BeraFlags", () => ({
+  useBeraFlag: () => false,
+}));
+
+vi.mock("../../actions/dex/aggregators/enso/ensoErc4626", () => ({
+  ensoErc4626: { getQuote },
+}));
+
+vi.mock("../dex/usePriceImpact", () => ({
+  usePriceImpact: () => ({ data: null }),
+}));
+
+const inputToken = {
+  address: "0xFCBD14d472B1C3Ff25139Aba7D7aCE0C12fFf4d8",
+  decimals: 18,
+  symbol: "HONEY",
+  name: "Honey",
+  chainId: 80094,
+} as const satisfies MinimalERC20;
+
+const underlyingToken = {
+  address: "0x6969696969696969696969696969696969696969",
+  decimals: 18,
+  symbol: "WBERA",
+  name: "Wrapped BERA",
+  chainId: 80094,
+} as const satisfies MinimalERC20;
+
+const tokenOut = {
+  address: "0x118D2cEeE9785eaf70C15Cd74CD84c9f8c3EeC9a",
+  decimals: 18,
+  symbol: "sWBERA",
+  name: "Staked WBERA",
+  chainId: 80094,
+} as const satisfies MinimalERC20;
+
+describe("useZapStakeBera", () => {
+  beforeEach(() => {
+    captured.key = null;
+    captured.fetcher = null;
+    getQuote.mockReset();
+  });
+
+  it("reads the proxy transport from the SWR key", async () => {
+    useZapStakeBera({
+      inputToken,
+      amount: "1",
+      underlyingToken,
+      slippage: 0.5,
+      tokenOut,
+    });
+
+    expect(captured.key?.at(-1)).toBe(false);
+    expect(captured.fetcher).not.toBeNull();
+
+    const proxyKey = [...(captured.key ?? [])];
+    proxyKey[proxyKey.length - 1] = true;
+    await captured.fetcher?.(proxyKey);
+
+    expect(getQuote).toHaveBeenCalledWith(
+      expect.objectContaining({
+        proxyAggregatorsThroughVercel: true,
+      }),
+    );
+  });
+});

package/src/hooks/exports.ts

@@ -13,6 +13,7 @@ export * from "./dex/useAllUserPools";
 export * from "./dex/useApiPool";
 export * from "./dex/useBexStatus";
 export * from "./dex/useCreatePool";
+export * from "./dex/useCrossChainNativeFee";
 export { useGlobalLiquidityAndSwapVolume } from "./dex/useGlobalLiquidityAndSwapVolume";
 export * from "./dex/useLiquidityMismatch";
 export * from "./dex/useLpPosition";
@@ -32,7 +33,6 @@ export {
 export * from "./enso/useBendDemultiply";
 export * from "./enso/useBendMultiply";
 export * from "./enso/useBendZapSupply";
-export * from "./enso/useEnsoSwapBundle";
 export * from "./enso/useEnsoUserTokensWithBalances";
 export * from "./enso/useZapStakeBera";
 export * from "./honey/useCappedGlobally";
@@ -51,7 +51,6 @@ export * from "./perps/usePythUpdateFee";
 export { useAutoclaimedIncentives } from "./pol/useAutoclaimedIncentives";
 export { useAutoclaimedIncentivesTxHash } from "./pol/useAutoclaimedIncentivesTxHash";
 export * from "./pol/useBgtAprSimulation";
-export { useBgtIncentiveDistributorPaused } from "./pol/useBgtIncentiveDistributorPaused";
 export { useBgtUnstakedBalance } from "./pol/useBgtUnstakedBalance";
 export { useClaimableFees } from "./pol/useClaimableFees";
 export * from "./pol/useHighestVaultsAPR";
@@ -66,7 +65,7 @@ export * from "./pol/useRewardVaultIncentives";
 export { useRewardVaultRewards } from "./pol/useRewardVaultRewards";
 export * from "./pol/useRewardVaults";
 export { useRewardVaults } from "./pol/useRewardVaults";
-export * from "./pol/useStakedAPR";
+export * from "./pol/useStakedAPY";
 export * from "./pol/useStakedData";
 export * from "./pol/useStakedSnapshots";
 export * from "./pol/useStakingVaultsMetadata";
@@ -104,10 +103,8 @@ export {
 export * from "./validators/useStakingPoolBatch";
 export { useUserActiveValidators } from "./validators/useUserActiveValidators";
 export { useUserBoostsOnValidator } from "./validators/useUserBoostsOnValidator";
-export { useUserClaimableIncentives } from "./validators/useUserClaimableIncentives";
 export * from "./validators/useUserStakingPositions";
 export * from "./validators/useValidator";
-export { useValidatorAnalytics } from "./validators/useValidatorAnalytics";
 export { useValidatorCommission } from "./validators/useValidatorCommission";
 export { useValidatorEstimatedBgtPerYear } from "./validators/useValidatorEstimatedBgtPerYear";
 export { useValidatorIncentiveDistribution } from "./validators/useValidatorIncentiveDistribution";

package/src/hooks/pol/useAutoclaimedIncentives.ts

@@ -4,11 +4,12 @@ import { useSWR } from "@berachain/utils/pkg/swr";
 import { getAutoclaimedIncentives } from "../../actions/pol/getAutoclaimedIncentives";
 import type { AutoclaimedIncentivesResponse } from "../../types/bribeBoost";
 import type { DefaultHookReturnType } from "../../types/global";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
 
 interface UseAutoclaimedIncentivesArgs {
   // Hard gate: when false the SWR key is null, so the API is never called.
-  // The banner consumer flips this to true only after both `!isBgtPolRewardToken`
-  // and `bgtIncentiveDistributor.paused() === true` have been verified.
+  // The banner consumer flips this to true only after
+  // `bgtIncentiveDistributor.paused() === true` has been verified.
   enabled: boolean;
 }
 
@@ -16,9 +17,11 @@ export function useAutoclaimedIncentives({
   enabled,
 }: UseAutoclaimedIncentivesArgs): DefaultHookReturnType<AutoclaimedIncentivesResponse | null> {
   const { address: account } = useBeraWallet();
+  const { config } = parseBaseArgs({});
 
   const QUERY_KEY =
-    enabled && account
+    // `bribeBoostApi` is null on chains where the endpoint is shut down.
+    enabled && account && config.pol.bribeBoostApi
       ? (["useAutoclaimedIncentives", account] as const)
       : null;
 

package/src/hooks/pol/useAutoclaimedIncentivesTxHash.ts

@@ -5,10 +5,11 @@ import { getAutoclaimedIncentivesTxHash } from "../../actions/pol/getAutoclaimed
 import { POLLING } from "../../enum/polling";
 import type { AutoclaimedIncentivesTxHashResponse } from "../../types/bribeBoost";
 import type { DefaultHookReturnType } from "../../types/global";
+import { parseBaseArgs } from "../../utils/parseBaseArgs";
 
 interface UseAutoclaimedIncentivesTxHashArgs {
   // Hard gate, identical to `useAutoclaimedIncentives` — only flip true once
-  // both `!isBgtPolRewardToken` and `bgtIncentiveDistributor.paused()` hold.
+  // `bgtIncentiveDistributor.paused()` holds.
   enabled: boolean;
 }
 
@@ -16,9 +17,11 @@ export function useAutoclaimedIncentivesTxHash({
   enabled,
 }: UseAutoclaimedIncentivesTxHashArgs): DefaultHookReturnType<AutoclaimedIncentivesTxHashResponse | null> {
   const { address: account } = useBeraWallet();
+  const { config } = parseBaseArgs({});
 
   const QUERY_KEY =
-    enabled && account
+    // `bribeBoostApi` is null on chains where the endpoint is shut down.
+    enabled && account && config.pol.bribeBoostApi
       ? (["useAutoclaimedIncentivesTxHash", account] as const)
       : null;
 

package/src/hooks/pol/useRewardTokenToBeraRate.ts

@@ -17,10 +17,11 @@ export function useRewardTokenToBeraRate(
   },
   opt?: DefaultHookOptions,
 ) {
-  const QUERY_KEY = address
-    ? (["useRewardTokenToBeraRate", address] as const)
-    : null;
   const publicClient = usePublicClient({ chainId: defaultChainId });
+  const QUERY_KEY =
+    address && publicClient
+      ? (["useRewardTokenToBeraRate", address] as const)
+      : null;
 
   return useSWR(
     QUERY_KEY,
@@ -29,7 +30,7 @@ export function useRewardTokenToBeraRate(
       assertPublicClient(publicClient);
 
       return getRewardTokenToBeraRate({
-        address: address as `0x${string}`,
+        address,
         publicClient,
       });
     },

package/src/hooks/pol/useRewardVaultBalanceFromStakingToken.ts

@@ -26,7 +26,6 @@ export function useRewardVaultBalanceFromStakingToken(
   const isEnabled = options?.isEnabled ?? true;
   const {
     data: rewardVaultAddress = _rewardVaultAddress,
-    error,
     refresh: mutateRewardVaultAddress,
     isLoading: isLoadingRewardVaultAddress,
   } = useRewardVaultFromToken(

package/src/hooks/pol/{useStakedAPR.ts → useStakedAPY.ts}

@@ -1,20 +1,22 @@
-import type { GqlVaultSnapshotDataRange } from "@berachain/graphql/dex/api";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
-import { getStakedBeraSnapshots } from "../../actions/pol/getStakedBeraSnapshots";
+import {
+  getStakedBeraSnapshots,
+  type StakeSnapshotRange,
+} from "../../actions/pol/getStakedBeraSnapshots";
 import type { DefaultHookReturnType } from "../../types/global";
 import { dailyResolution } from "../../utils/filter";
 
-type UseStakedAPR = {
+type UseStakedAPY = {
   timestamp: number;
-  apr: string;
+  apy: number | null;
 }[];
-export function useStakedAPR({
+export function useStakedAPY({
   range,
 }: {
-  range: GqlVaultSnapshotDataRange;
-}): DefaultHookReturnType<UseStakedAPR> {
-  const QUERY_KEY = range ? (["useStakedAPR", range] as const) : null;
+  range: StakeSnapshotRange;
+}): DefaultHookReturnType<UseStakedAPY> {
+  const QUERY_KEY = range ? (["useStakedAPY", range] as const) : null;
   return useSWR(QUERY_KEY, async ([, range]) => {
     const unsortedStakedBeraSnapshots = await getStakedBeraSnapshots({
       range,
@@ -26,7 +28,7 @@ export function useStakedAPR({
 
     return sortedStakedBeraSnapshots.map((item) => ({
       timestamp: item.timestamp,
-      apr: item.apr,
+      apy: item.apy,
     }));
   });
 }

package/src/hooks/pol/useStakedData.ts

@@ -2,11 +2,11 @@ import { useMemo } from "react";
 
 import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
 import BigNumber from "@berachain/utils/pkg/bignumber.js";
-import { useSWR } from "@berachain/utils/pkg/swr";
+import { useSWR, useSWRImmutable } from "@berachain/utils/pkg/swr";
 
 import { getEarnedStakedBeraVault } from "../../actions/pol/getEarnedStakedBeraVault";
 import { getRewardTokenToBeraRate } from "../../actions/pol/getRewardTokenToBeraRate";
-import { getStakedBeraAPR } from "../../actions/pol/getStakedBeraAPR";
+import { getStakedBeraAPY } from "../../actions/pol/getStakedBeraAPY";
 import { useBeraFlag } from "../../contexts/BeraFlags/BeraFlags";
 import { POLLING } from "../../enum/polling";
 import { assertPublicClient } from "../../errors/assert";
@@ -18,7 +18,7 @@ import { useTokenPrices } from "../tokens/useTokenPrices";
 /**
  * Fetches staked asset data in two phases for progressive loading:
  *
- * 1. APR — independent fetch, resolves quickly, shared by both phases.
+ * 1. APY — independent fetch, resolves quickly, shared by both phases.
  * 2. Balances (fast path) — wallet balances (via usePollWalletBalances),
  *    token prices (via useTokenPrices), and exchange rates.
  *    Provides staked amounts and USD values immediately (earnings are 0).
@@ -42,12 +42,11 @@ export function useStakedData(stakingConfigs: StakingConfig[]) {
     [stakingConfigs],
   );
 
-  // APR — only updates every ~12 hours on BE
-  const aprKey = window ? (["useStakedData:apr", window] as const) : null;
-  const { data: apr } = useSWR(
-    aprKey,
-    async ([, window]) => getStakedBeraAPR({ window }),
-    { refreshInterval: POLLING.NORMAL },
+  // APY — only updates every ~12 hours on BE
+  const apyKey = window ? (["useStakedData:apy", window] as const) : null;
+
+  const { data: apy } = useSWRImmutable(apyKey, async ([, window]) =>
+    getStakedBeraAPY({ window }),
   );
 
   const {
@@ -152,7 +151,7 @@ export function useStakedData(stakingConfigs: StakingConfig[]) {
 
       return {
         token: inputToken,
-        apr,
+        apy,
         stakedAmount: stakedAmount.toNumber(),
         stakedAmountUsd,
         earnedAmount: 0,
@@ -164,7 +163,7 @@ export function useStakedData(stakingConfigs: StakingConfig[]) {
     walletBalances,
     exchangeRates,
     stakingConfigs,
-    apr,
+    apy,
     getTokenPrice,
     earningsSettled,
   ]);
@@ -205,16 +204,18 @@ export function useStakedData(stakingConfigs: StakingConfig[]) {
 
       return {
         token: inputToken,
-        apr,
+        apy,
         stakedAmount: stakedAmount.toNumber(),
         earnedAmount: earnedAmount.toNumber(),
         stakedAmountUsd,
         earnedAmountUsd,
       };
     });
-  }, [positionsRaw, walletBalances, stakingConfigs, apr, getTokenPrice]);
+  }, [positionsRaw, walletBalances, stakingConfigs, apy, getTokenPrice]);
 
   return {
+    /** Overall staked-BERA APY. Wallet-independent. */
+    apy,
     /** Fast path: staked amounts + USD values (no earnings) */
     balances,
     /** Slow path: full enriched positions with earnings */
@@ -227,7 +228,7 @@ export function useStakedData(stakingConfigs: StakingConfig[]) {
     /**
      * Hard error: the RPC fast-path could not produce staked balances (wallet
      * balances or exchange-rate reads failed). Price and earnings backend
-     * failures are intentionally excluded — those degrade gracefully (USD/APR
+     * failures are intentionally excluded — those degrade gracefully (USD/APY
      * render as "—", earnings stop loading) so RPC-derived amounts still show.
      */
     error: walletBalancesError ?? exchangeRatesError,

package/src/hooks/pol/useStakedSnapshots.ts

@@ -1,9 +1,9 @@
 import type { Address } from "viem";
 
-import type { StakeStatsByDayResponse } from "@berachain/graphql/beep";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
 import { getStakingDailyAssets } from "../../actions/pol/getStakingDailyAssets";
+import type { StakeStatsByDayResponse } from "../../generated/beep";
 import type { DefaultHookReturnType } from "../../types/global";
 import { dailyResolution } from "../../utils/filter";
 

package/src/hooks/pol/useStakingVaultsMetadata.ts

@@ -4,33 +4,28 @@ import { usePublicClient } from "@berachain/wagmi/hooks";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
 import { getSWBeraVaultMetadata } from "../../actions/pol/getSWBeraVaultMetadata";
-import { useBlockTime } from "../../contexts/BlockTimeProvider";
 import { POLLING } from "../../enum/polling";
 import { assertPublicClient } from "../../errors/assert";
 
 export type StakingVaultEntry = {
   address: Address;
-  underlyingAsset: Address;
 };
 
 export function useStakingVaultsMetadata(vaults: StakingVaultEntry[] = []) {
   const publicClient = usePublicClient();
-  const blockTime = useBlockTime();
   const QUERY_KEY =
-    vaults.length > 0 && publicClient && blockTime
-      ? (["useStakingVaultMetadata", vaults, publicClient, blockTime] as const)
+    vaults.length > 0 && publicClient
+      ? (["useStakingVaultMetadata", vaults] as const)
       : null;
   return useSWR(
     QUERY_KEY,
-    async ([, vaults, publicClient, blockTime]) => {
+    async ([, vaults]) => {
       assertPublicClient(publicClient);
       return Promise.all(
         vaults.map((vault) =>
           getSWBeraVaultMetadata({
             address: vault.address,
-            underlyingAsset: vault.underlyingAsset,
             publicClient,
-            blockTime,
           }),
         ),
       );

package/src/hooks/tokens/useMultipleTokenInformation.ts

@@ -1,12 +1,13 @@
-import { isAddress } from "viem";
+import type { PublicClient } from "viem";
 
+import type { ChainId } from "@berachain/config";
 import { defaultChainId } from "@berachain/config/internal";
 
 import { usePublicClient } from "@berachain/wagmi/hooks";
 import { useSWRImmutable } from "@berachain/utils/pkg/swr";
 
 import { getTokenInformation } from "../../actions/tokens/getTokenInformation";
-import { assertPublicClient } from "../../errors/assert";
+import { assertAddress, assertPublicClient } from "../../errors/assert";
 import type { Token } from "../../types/dex";
 import type {
   DefaultHookOptions,
@@ -17,10 +18,66 @@ export type UseMultipleTokenInformationResponse = DefaultHookReturnType<
   Token[]
 >;
 
+/**
+ * Resolve ERC20 metadata for a batch of addresses, best-effort. An address whose
+ * metadata can't be read — a non-ERC20 / codeless contract (e.g. a single-asset
+ * staking vault whose `decimals()` reverts), an invalid address, or a missing
+ * token — is simply omitted from the result rather than failing the whole batch.
+ * Consumers key results by address and treat a missing entry as absent.
+ */
+export async function fetchMultipleTokenInformation({
+  addresses,
+  publicClient,
+  chainId,
+}: {
+  addresses: readonly string[];
+  publicClient: PublicClient;
+  chainId: ChainId;
+}): Promise<Token[]> {
+  const settled = await Promise.allSettled(
+    addresses.map(async (address) => {
+      assertAddress(address, "address");
+
+      const tk = await getTokenInformation({
+        address,
+        publicClient,
+        chainId,
+      });
+
+      if (!tk) {
+        throw new Error(`Token ${address} not found`);
+      }
+
+      return tk;
+    }),
+  );
+
+  return settled
+    .filter((r): r is PromiseFulfilledResult<Token> => r.status === "fulfilled")
+    .map((r) => r.value);
+}
+
 export type useMultipleTokenInformationArgs = {
+  /** Addresses to resolve metadata for. `undefined` disables the query. */
   addresses: string[] | readonly string[] | undefined;
+  /** Chain to read from. Defaults to the app's `defaultChainId`. */
   chainId?: number;
 };
+
+/**
+ * Batch-resolves ERC20 metadata for `addresses`, best-effort.
+ *
+ * Metadata resolution is best-effort:
+ * any address that can't be resolved — a non-ERC20 / codeless contract (e.g. a
+ * single-asset staking vault whose `decimals()` reverts), an invalid address, or
+ * a missing token — is OMITTED rather than failing the whole batch. So the result
+ * length and order do not necessarily match the input `addresses`.
+ *
+ * ⚠️ The returned array is NOT positional.
+ * Do NOT index the result positionally (`data[i]` for `addresses[i]`). Always
+ * look tokens up by address, e.g. `data?.find(t => t.address === addr)` or build
+ * an address-keyed map.
+ */
 export function useMultipleTokenInformation(
   args: useMultipleTokenInformationArgs,
   options?: DefaultHookOptions,
@@ -44,25 +101,11 @@ export function useMultipleTokenInformation(
       // but we need this for correct type inference
       assertPublicClient(publicClient);
 
-      return Promise.all(
-        addresses.map(async (address) => {
-          if (!address || !isAddress(address, { strict: false })) {
-            throw new Error("Invalid address");
-          }
-
-          const tk = await getTokenInformation({
-            address: address,
-            publicClient,
-            chainId,
-          });
-
-          if (!tk) {
-            throw new Error(`Token ${address} not found`);
-          }
-
-          return tk;
-        }),
-      );
+      return fetchMultipleTokenInformation({
+        addresses,
+        publicClient,
+        chainId,
+      });
     },
     { ...options },
   );

package/src/hooks/tokens/useMultipleTokenInformation.unit.test.ts

@@ -0,0 +1,91 @@
+import type { Address, PublicClient } from "viem";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ChainId } from "@berachain/config/internal";
+
+import { getTokenInformation } from "../../actions/tokens/getTokenInformation";
+import type { Token } from "../../types/dex";
+import { fetchMultipleTokenInformation } from "./useMultipleTokenInformation";
+
+vi.mock("../../actions/tokens/getTokenInformation", () => ({
+  getTokenInformation: vi.fn(),
+}));
+
+const mockGetTokenInformation = vi.mocked(getTokenInformation);
+
+// publicClient is only forwarded to (the mocked) getTokenInformation, so a stub
+// is enough here.
+const publicClient = {} as unknown as PublicClient;
+const chainId = ChainId.MAINNET;
+
+const ADDR_A = "0xac03caba51e17c86c921e1f6cbfbdc91f8bb2e6b" as Address;
+const ADDR_B = "0xbaadcc2962417c01af99fb2b7c75706b9bd6babe" as Address;
+const STAKING_CONTRACT =
+  "0x75f3be06b02e235f6d0e7ef2d462b29739168301" as Address;
+
+function makeToken(address: Address, symbol: string): Token {
+  return {
+    address,
+    decimals: 18,
+    symbol,
+    name: symbol,
+    chainId,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("fetchMultipleTokenInformation", () => {
+  it("omits an address whose metadata read reverts instead of rejecting the batch", async () => {
+    // Simulates a non-ERC20 single-asset staking contract: `decimals()` reverts,
+    // so getTokenInformation rethrows.
+    mockGetTokenInformation.mockImplementation(async ({ address }) => {
+      if (address === STAKING_CONTRACT) {
+        throw new Error('The contract function "decimals" reverted.');
+      }
+      return makeToken(address, address === ADDR_A ? "iBGT" : "LBGT");
+    });
+
+    const result = await fetchMultipleTokenInformation({
+      addresses: [ADDR_A, STAKING_CONTRACT, ADDR_B],
+      publicClient,
+      chainId,
+    });
+
+    expect(result).toHaveLength(2);
+    expect(result.map((t) => t.address)).toEqual([ADDR_A, ADDR_B]);
+    expect(result.some((t) => t.address === STAKING_CONTRACT)).toBe(false);
+  });
+
+  it("drops invalid addresses without reading them", async () => {
+    mockGetTokenInformation.mockImplementation(async ({ address }) =>
+      makeToken(address, "iBGT"),
+    );
+
+    const result = await fetchMultipleTokenInformation({
+      addresses: ["not-an-address", ADDR_A],
+      publicClient,
+      chainId,
+    });
+
+    expect(result.map((t) => t.address)).toEqual([ADDR_A]);
+    // The invalid address never reaches getTokenInformation.
+    expect(mockGetTokenInformation).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns all tokens for an all-valid batch, preserving order", async () => {
+    mockGetTokenInformation.mockImplementation(async ({ address }) =>
+      makeToken(address, address === ADDR_A ? "iBGT" : "LBGT"),
+    );
+
+    const result = await fetchMultipleTokenInformation({
+      addresses: [ADDR_A, ADDR_B],
+      publicClient,
+      chainId,
+    });
+
+    expect(result.map((t) => t.address)).toEqual([ADDR_A, ADDR_B]);
+  });
+});

package/src/hooks/tokens/usePollBalance.ts

@@ -110,8 +110,10 @@ export function usePollBalance(
 
   return {
     ...rest,
-    isLoading: isLoading || isNativeToken ? isLoadingTokenInformation : false,
-    error: error || !isNativeToken ? error : undefined,
+    isLoading: isNativeToken
+      ? isLoading
+      : isLoading || isLoadingTokenInformation,
+    error,
     data: tokenBalance,
   };
 }