@berachain/berajs 0.2.13 → 0.3.1

package/src/hooks/dex/useAggregatorsQuotes.ts

@@ -183,7 +183,13 @@ export function useAggregatorsQuotes(
       ...args,
       aggregator: bex,
     },
-    { ...swrOptions, isEnabled: bexProtocol.isPaused === false },
+    {
+      ...swrOptions,
+      // Compose with the caller's gate (e.g. same-token suppression from
+      // useSwap) instead of overwriting it — otherwise bex fetches whenever
+      // it's unpaused, regardless of isEnabled (HUB-9FQ).
+      isEnabled: (options?.isEnabled ?? true) && bexProtocol.isPaused === false,
+    },
   );
 
   const wberaSwapResult = raw_useSingleAggregatorQuote({

package/src/hooks/dex/useCrossChainNativeFee.ts

@@ -0,0 +1,83 @@
+"use client";
+
+import { formatEther, zeroAddress } from "viem";
+
+import { usePollBalance } from "../tokens/usePollBalance";
+
+/**
+ * Whether the source-chain native balance fails to cover the tx value.
+ *
+ * Same-chain zaps never qualify: their tx `value` is the native amount being
+ * swapped (e.g. BERA → HONEY), not a bridge fee, so treating it as a fee would
+ * always flag the balance short. Extracted (and exported) so the branch is
+ * unit-testable without a React renderer.
+ */
+export function isNativeFeeInsufficient({
+  isCrossChain,
+  value,
+  nativeBalance,
+  isLoading,
+}: {
+  isCrossChain: boolean;
+  value: bigint;
+  nativeBalance: bigint;
+  isLoading: boolean;
+}): boolean {
+  if (!isCrossChain) return false;
+  return value > 0n && !isLoading && value > nativeBalance;
+}
+
+/**
+ * Cross-chain zaps pay the LayerZero bridge fee out of the source-chain native
+ * balance (it's baked into the tx `value`). This polls that native balance and
+ * reports whether it covers the fee, so the shared warning/gas-reserve UI stops
+ * being copy-pasted per call site. Only polls when a cross-chain route exists —
+ * `srcChainId` is passed undefined otherwise.
+ */
+export function useCrossChainNativeFee({
+  srcChainId,
+  value,
+}: {
+  /** Source chain the tx (and bridge fee) lives on. Undefined ⇒ not cross-chain, no poll. */
+  srcChainId: number | undefined;
+  /** The tx value in wei, including the bridge fee. */
+  value: bigint;
+}): {
+  nativeFee?: string;
+  hasInsufficientNativeBalance: boolean;
+  isNativeBalanceLoading: boolean;
+} {
+  const isCrossChain = srcChainId !== undefined;
+
+  const { data: nativeBalanceData, isLoading: isNativeBalanceLoading } =
+    usePollBalance(
+      {
+        address: zeroAddress,
+        chainId: isCrossChain ? srcChainId : undefined,
+      },
+      { isEnabled: isCrossChain },
+    );
+
+  // For a same-chain zap the tx `value` is the native amount being swapped, not
+  // a bridge fee — so there's no fee to display or check.
+  if (!isCrossChain) {
+    return {
+      nativeFee: undefined,
+      hasInsufficientNativeBalance: false,
+      isNativeBalanceLoading: false,
+    };
+  }
+
+  const nativeBalance = BigInt(nativeBalanceData?.balance.raw ?? 0n);
+
+  return {
+    nativeFee: value > 0n ? formatEther(value) : undefined,
+    hasInsufficientNativeBalance: isNativeFeeInsufficient({
+      isCrossChain,
+      value,
+      nativeBalance,
+      isLoading: isNativeBalanceLoading,
+    }),
+    isNativeBalanceLoading,
+  };
+}

package/src/hooks/dex/useCrossChainNativeFee.unit.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "vitest";
+
+import { isNativeFeeInsufficient } from "./useCrossChainNativeFee";
+
+describe("isNativeFeeInsufficient", () => {
+  // Regression (PR #1965 review): a same-chain native-in zap (e.g. BERA → HONEY)
+  // has a non-zero tx value that is the swap amount, not a bridge fee. It must
+  // never be flagged as insufficient native balance.
+  test("same-chain zap is never insufficient, even with a large value", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: false,
+        value: 10n ** 18n,
+        nativeBalance: 0n,
+        isLoading: false,
+      }),
+    ).toBe(false);
+  });
+
+  test("cross-chain: insufficient when value exceeds native balance", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: true,
+        value: 2n,
+        nativeBalance: 1n,
+        isLoading: false,
+      }),
+    ).toBe(true);
+  });
+
+  test("cross-chain: sufficient when balance covers the fee", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: true,
+        value: 1n,
+        nativeBalance: 5n,
+        isLoading: false,
+      }),
+    ).toBe(false);
+  });
+
+  test("cross-chain: not flagged while the balance is still loading", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: true,
+        value: 2n,
+        nativeBalance: 0n,
+        isLoading: true,
+      }),
+    ).toBe(false);
+  });
+
+  test("cross-chain: zero value is never insufficient", () => {
+    expect(
+      isNativeFeeInsufficient({
+        isCrossChain: true,
+        value: 0n,
+        nativeBalance: 0n,
+        isLoading: false,
+      }),
+    ).toBe(false);
+  });
+});

package/src/hooks/dex/useOnChainPoolData.ts

@@ -93,17 +93,16 @@ export function useOnChainPoolData(poolId: string) {
       return undefined;
     }
 
-    const pool: OnChainPoolFragment = {
-      address: address.toLowerCase() as Address,
-      id: poolId.toLowerCase() as string,
-      type: poolData.type,
-      factory: poolData.factory,
-      totalShares: poolData.totalSupply,
-      totalLiquidity: "0", // overwritten below
-      swapFee: poolData.swapFee,
-      createTime: 0,
-      name: poolData.name,
-      tokens: tokenInformation.map((token, idx) => ({
+    const infoByAddress = new Map(
+      tokenInformation.map(
+        (token) => [token.address.toLowerCase(), token] as const,
+      ),
+    );
+
+    const tokens = poolData.poolTokens[0].map((rawAddress, idx) => {
+      const token = infoByAddress.get(rawAddress.toLowerCase());
+      if (!token) return null;
+      return {
         address: token.address.toLowerCase() as Address,
         name: token.name,
         decimals: token.decimals,
@@ -115,11 +114,29 @@ export function useOnChainPoolData(poolId: string) {
           token.decimals,
         ),
         token: {
-          __typename: "Token",
+          __typename: "Token" as const,
           token,
           latestUSDPrice: tokenPrices?.[token.address],
         },
-      })),
+      };
+    });
+
+    // A pool token whose metadata couldn't be resolved leaves the pool incomplete;
+    if (tokens.some((token) => token === null)) {
+      return undefined;
+    }
+
+    const pool: OnChainPoolFragment = {
+      address: address.toLowerCase() as Address,
+      id: poolId.toLowerCase() as string,
+      type: poolData.type,
+      factory: poolData.factory,
+      totalShares: poolData.totalSupply,
+      totalLiquidity: "0", // overwritten below
+      swapFee: poolData.swapFee,
+      createTime: 0,
+      name: poolData.name,
+      tokens: tokens as NonNullable<(typeof tokens)[number]>[],
       amplificationParameter: poolData?.amplificationParameter && {
         // For example, if value is 300000n and precision is 1000n, the user-set amplification parameter would be 300000n / 1000n = 300n.
         currentFormattedValue:

package/src/hooks/dex/useSingleAggregatorQuote.ts

@@ -54,6 +54,7 @@ type IQueryKey = readonly [
   Address | undefined, // rewardVault
   MinimalERC20 | null | undefined, // underlyingToken
   TokenWithOrder[] | undefined, // collateralList
+  boolean, // proxyAggregatorsThroughVercel
 ];
 
 export const USE_AGGREGATORS_QUOTES_QUERY_KEY = "useAggregatorsQuotes";
@@ -70,6 +71,7 @@ function getQueryKey({
   feeBps,
   activeAggregators,
   isMAEnabled,
+  proxyAggregatorsThroughVercel,
 }: {
   aggregator: BaseAggregator;
   account: Address | undefined;
@@ -82,17 +84,20 @@ function getQueryKey({
    */
   activeAggregators: string[] | undefined;
   isMAEnabled: boolean;
+  proxyAggregatorsThroughVercel: boolean | undefined;
 }): IQueryKey | null {
   if (!Number(args.amount)) {
     return null;
   }
+
   if (
-    !aggregator.checkChainSupport({
+    aggregator.getUnsupportedReason({
       tokenIn: args.tokenIn,
       tokenOut: args.tokenOut,
       underlyingToken: args.underlyingToken,
       honeyNativeState: args.honeyNativeState,
-    })
+      rewardVault: args.rewardVault,
+    }) !== null
   ) {
     return null;
   }
@@ -156,6 +161,7 @@ function getQueryKey({
     aggregator.name === Aggregators.Honey
       ? args.honeyNativeState?.collateralList
       : undefined,
+    proxyAggregatorsThroughVercel ?? false,
   ];
 }
 
@@ -166,11 +172,9 @@ function getQueryKey({
 function getQueryFn({
   aggregator,
   publicClient,
-  proxyAggregatorsThroughVercel,
 }: {
   aggregator: BaseAggregator;
   publicClient?: PublicClient;
-  proxyAggregatorsThroughVercel?: boolean;
 }) {
   return async ([
     ,
@@ -185,6 +189,7 @@ function getQueryFn({
     rewardVault,
     underlyingToken,
     honeyCollaterals,
+    proxyAggregatorsThroughVercel,
   ]: IQueryKey) =>
     aggregator.getQuote({
       tokenIn,
@@ -240,10 +245,10 @@ export function raw_useSingleAggregatorQuote(
       feeBps,
       activeAggregators,
       isMAEnabled,
+      proxyAggregatorsThroughVercel,
     }),
     getQueryFn({
       aggregator: args.aggregator,
-      proxyAggregatorsThroughVercel,
       publicClient,
     }),
     options,

package/src/hooks/dex/useSingleAggregatorQuote.unit.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { BaseAggregator } from "../../actions/dex/aggregators/base";
+import { Aggregators } from "../../enum/dex";
+import type { MinimalERC20 } from "../../types/dex";
+import { raw_useSingleAggregatorQuote } from "./useSingleAggregatorQuote";
+
+type CapturedFetcher = (key: readonly unknown[]) => Promise<unknown>;
+
+const { captured } = vi.hoisted(() => ({
+  captured: {
+    key: null as readonly unknown[] | null,
+    fetcher: null as CapturedFetcher | null,
+  },
+}));
+
+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() };
+    },
+  ),
+}));
+
+const tokenIn = {
+  address: "0x6969696969696969696969696969696969696969",
+  decimals: 18,
+  symbol: "WBERA",
+  name: "Wrapped BERA",
+  chainId: 80094,
+} as const satisfies MinimalERC20;
+
+const tokenOut = {
+  address: "0xFCBD14d472B1C3Ff25139Aba7D7aCE0C12fFf4d8",
+  decimals: 18,
+  symbol: "HONEY",
+  name: "Honey",
+  chainId: 80094,
+} as const satisfies MinimalERC20;
+
+describe("raw_useSingleAggregatorQuote", () => {
+  beforeEach(() => {
+    captured.key = null;
+    captured.fetcher = null;
+    vi.clearAllMocks();
+  });
+
+  it("reads the proxy transport from the SWR key", async () => {
+    const getQuote = vi.fn().mockResolvedValue(undefined);
+    const aggregator = {
+      name: Aggregators.Oogabooga,
+      needsAccountForQuote: false,
+      getUnsupportedReason: () => null,
+      getQuote,
+    } as unknown as BaseAggregator;
+
+    raw_useSingleAggregatorQuote({
+      aggregator,
+      tokenIn,
+      tokenOut,
+      amount: "1",
+      slippage: 0.5,
+      account: undefined,
+      feeBps: 10,
+      activeAggregators: undefined,
+      isMAEnabled: true,
+      publicClient: undefined,
+      proxyAggregatorsThroughVercel: false,
+    });
+
+    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/enso/useBendZapSupply.ts

@@ -1,8 +1,6 @@
 "use client";
 
-import { type Address, formatEther, parseUnits, zeroAddress } from "viem";
-
-import { defaultChainId as berachainChainId } from "@berachain/config/internal";
+import { type Address, parseUnits, zeroAddress } from "viem";
 
 import { useBeraWallet, usePublicClient } from "@berachain/wagmi/hooks";
 import { useSWR } from "@berachain/utils/pkg/swr";
@@ -19,9 +17,8 @@ import type { BalanceToken, MinimalERC20 } from "../../types/dex";
 import type { DefaultHookOptions } from "../../types/global";
 import { isToken } from "../../utils/tokens";
 import { useGetConvertToAssets } from "../bend/useGetConvertToAssets";
+import { useCrossChainNativeFee } from "../dex/useCrossChainNativeFee";
 import { usePriceImpact } from "../dex/usePriceImpact";
-import { usePollBalance } from "../tokens/usePollBalance";
-import { useTokenPrices } from "../tokens/useTokenPrices";
 
 type UseBendZapSupplyArgs = {
   /*
@@ -69,10 +66,6 @@ export function useBendZapSupply(
   }: UseBendZapSupplyArgs,
   options?: DefaultHookOptions,
 ) {
-  const { getTokenPrice } = useTokenPrices({
-    tokens: tokenIn && loanToken ? [tokenIn, loanToken] : undefined,
-  });
-
   const swrResponse = useBendZapSupplyHelper(
     {
       tokenIn,
@@ -106,39 +99,17 @@ export function useBendZapSupply(
     },
   );
 
-  const isCrossChain = tokenIn?.chainId && tokenIn.chainId !== berachainChainId;
+  const isCrossChain = swrResponse.data?.isCrossChain;
 
-  // fetch native token balance for source chain (needed for bridge fee check)
-  const { data: nativeBalanceData, isLoading: isNativeBalanceLoading } =
-    usePollBalance(
-      {
-        address: zeroAddress,
-        chainId: isCrossChain ? tokenIn?.chainId : undefined,
-      },
-      { isEnabled: !!isCrossChain },
-    );
-
-  // for cross-chain zaps, check if transaction value exceeds native token balance
-  // (tx.value includes bridge fees that must be paid in native token)
+  // for cross-chain zaps, tx.value includes the bridge fee (paid in native
+  // token on the source chain); check the source-chain native balance covers it.
   const transactionValue =
     swrResponse.data?.getCalldata?.({ account: zeroAddress })?.value ?? 0n;
 
-  // check if user has enough native token for bridge fees
-  const nativeBalance = nativeBalanceData?.balance ?? {
-    raw: "0",
-    formatted: "0",
-  };
-  const hasInsufficientNativeBalance =
-    isCrossChain &&
-    transactionValue > 0n &&
-    !isNativeBalanceLoading &&
-    transactionValue > BigInt(nativeBalance.raw);
-
-  // formatted native fee for gas reserve display
-  const nativeFee =
-    isCrossChain && transactionValue > 0n
-      ? formatEther(transactionValue)
-      : undefined;
+  const { hasInsufficientNativeBalance, nativeFee } = useCrossChainNativeFee({
+    srcChainId: isCrossChain ? swrResponse.data?.srcChainId : undefined,
+    value: transactionValue,
+  });
 
   return {
     ...swrResponse,
@@ -209,6 +180,7 @@ export function useBendZapSupplyHelper(
       rewardVault,
       amount,
       slippage,
+      proxyAggregatorsThroughVercel,
     ]) => {
       assertPublicClient(publicClientBeraChain);
       assertAddress(fromAddress, "fromAddress");

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

@@ -0,0 +1,98 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { BalanceToken, MinimalERC20 } from "../../types/dex";
+import { useBendZapSupplyHelper } from "./useBendZapSupply";
+
+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",
+  }),
+  usePublicClient: () => ({}),
+}));
+
+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 },
+}));
+
+const tokenIn = {
+  address: "0x6969696969696969696969696969696969696969",
+  decimals: 18,
+  symbol: "WBERA",
+  name: "Wrapped BERA",
+  chainId: 80094,
+  balance: {
+    raw: "1000000000000000000",
+    formatted: "1",
+  },
+} as const satisfies BalanceToken;
+
+const loanToken = {
+  address: "0xFCBD14d472B1C3Ff25139Aba7D7aCE0C12fFf4d8",
+  decimals: 18,
+  symbol: "HONEY",
+  name: "Honey",
+  chainId: 80094,
+} as const satisfies MinimalERC20;
+
+const bendVault = {
+  address: "0x2222222222222222222222222222222222222222",
+  decimals: 18,
+  symbol: "byvHONEY",
+  name: "Bend Honey Vault",
+  chainId: 80094,
+} as const satisfies MinimalERC20;
+
+describe("useBendZapSupplyHelper", () => {
+  beforeEach(() => {
+    captured.key = null;
+    captured.fetcher = null;
+    getQuote.mockReset();
+  });
+
+  it("reads the proxy transport from the SWR key", async () => {
+    useBendZapSupplyHelper({
+      tokenIn,
+      loanToken,
+      bendVault,
+      amount: "1000000000000000000",
+      slippage: 0.5,
+    });
+
+    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/enso/useEnsoUserTokensWithBalances.ts

@@ -1,3 +1,5 @@
+import { ChainId, defaultChainId } from "@berachain/config/internal";
+
 import { useBeraWallet, useConfig } from "@berachain/wagmi/hooks";
 import { useSWR } from "@berachain/utils/pkg/swr";
 
@@ -17,10 +19,9 @@ export function useEnsoUserTokensWithBalances(
   const proxyAggregatorsThroughVercel = useBeraFlag(
     "proxyAggregatorsThroughVercel",
   );
-  const isEnabled = !!fromAddress;
 
   const QUERY_KEY =
-    isEnabled && wagmiConfig
+    fromAddress && wagmiConfig
       ? ([
           "useEnsoUserTokensWithBalances",
           fromAddress,
@@ -31,7 +32,9 @@ export function useEnsoUserTokensWithBalances(
 
   return useSWR(
     QUERY_KEY,
-    async ([, fromAddress, chainId]): Promise<BalanceToken[]> =>
+    async ([, fromAddress, chainId, proxyAggregatorsThroughVercel]): Promise<
+      BalanceToken[]
+    > =>
       getEnsoUserTokensWithBalances({
         account: fromAddress,
         wagmiConfig,
@@ -43,6 +46,13 @@ export function useEnsoUserTokensWithBalances(
     {
       refreshInterval: POLLING.NORMAL,
       ...options,
+      // Enso only supports mainnet — on a Bepolia deployment `getBalances`
+      // returns a non-array, which the action reports as a warning (HUB-A1J).
+      // Don't query at all when the app isn't on an Enso-supported chain.
+      isEnabled:
+        chainId !== ChainId.BEPOLIA &&
+        defaultChainId !== ChainId.BEPOLIA &&
+        (options?.isEnabled ?? true),
     },
   );
 }

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

@@ -0,0 +1,69 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { useEnsoUserTokensWithBalances } from "./useEnsoUserTokensWithBalances";
+
+type CapturedFetcher = (key: readonly unknown[]) => Promise<unknown>;
+
+const { captured, getEnsoClient, getEnsoUserTokensWithBalances } = vi.hoisted(
+  () => ({
+    captured: {
+      key: null as readonly unknown[] | null,
+      fetcher: null as CapturedFetcher | null,
+    },
+    getEnsoClient: vi.fn(() => ({ getBalances: vi.fn() })),
+    getEnsoUserTokensWithBalances: vi.fn().mockResolvedValue([]),
+  }),
+);
+
+vi.mock("@berachain/wagmi/hooks", () => ({
+  useBeraWallet: () => ({
+    address: "0x1111111111111111111111111111111111111111",
+  }),
+  useConfig: () => ({ chains: [] }),
+}));
+
+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/clients/getEnsoClient", () => ({
+  getEnsoClient,
+}));
+
+vi.mock("../../actions/enso/getEnsoUserTokensWithBalances", () => ({
+  getEnsoUserTokensWithBalances,
+}));
+
+describe("useEnsoUserTokensWithBalances", () => {
+  beforeEach(() => {
+    captured.key = null;
+    captured.fetcher = null;
+    getEnsoClient.mockClear();
+    getEnsoUserTokensWithBalances.mockClear();
+  });
+
+  it("reads the proxy transport from the SWR key", async () => {
+    useEnsoUserTokensWithBalances({ chainId: 80094 });
+
+    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(getEnsoClient).toHaveBeenCalledWith({
+      baseURL: "/api/enso",
+    });
+  });
+});